Add Address struct with util helpers

Author: alex

lib/exw3/address.ex

@@ -0,0 +1,67 @@
+defmodule ExW3.Address do
+  @type t :: %__MODULE__{bytes: binary}
+
+  defstruct ~w[bytes]a
+
+  @spec from_bytes(binary) :: t
+  def from_bytes(bytes) do
+    %__MODULE__{bytes: bytes}
+  end
+
+  @spec from_hex(String.t()) :: t
+  def from_hex(address) do
+    case address do
+      "0x" <> a ->
+        from_hex(a)
+
+      a ->
+        bytes = a |> String.downcase() |> Base.decode16!(case: :lower)
+        %__MODULE__{bytes: bytes}
+    end
+  end
+
+  @spec to_bytes(t) :: binary
+  def to_bytes(%__MODULE__{bytes: bytes}) do
+    bytes
+  end
+
+  @spec to_string(t) :: String.t()
+  def to_string(%__MODULE__{bytes: bytes}) do
+    Base.encode16(bytes, case: :lower)
+  end
+
+  @spec to_hex(t) :: String.t()
+  def to_hex(%__MODULE__{} = address) do
+    "0x#{__MODULE__.to_string(address)}"
+  end
+
+  @spec to_checksum(t) :: String.t()
+  def to_checksum(%__MODULE__{} = address) do
+    address = address |> __MODULE__.to_string()
+    address_hash = address |> ExKeccak.hash_256() |> Base.encode16(case: :lower)
+
+    keccak_hash_list =
+      address_hash
+      |> String.split("", trim: true)
+      |> Enum.map(fn x -> elem(Integer.parse(x, 16), 0) end)
+
+    list_arr =
+      for n <- 0..(String.length(address) - 1) do
+        number = Enum.at(keccak_hash_list, n)
+
+        cond do
+          number >= 8 -> String.upcase(String.at(address, n))
+          true -> String.downcase(String.at(address, n))
+        end
+      end
+
+    "0x" <> List.to_string(list_arr)
+  end
+
+  @spec is_valid_checksum?(String.t()) :: boolean
+  def is_valid_checksum?(hex_address) do
+    address = hex_address |> __MODULE__.from_hex()
+    __MODULE__.to_checksum(address) == hex_address
+  end
+end
+

lib/exw3/utils.ex

@@ -1,4 +1,6 @@
 defmodule ExW3.Utils do
+  alias ExW3.Address
+
   @type invalid_hex_string :: :invalid_hex_string
   @type negative_integer :: :negative_integer
   @type non_integer :: :non_integer
@@ -86,39 +88,20 @@ defmodule ExW3.Utils do
     end
   end
 
+  @deprecated "Use ExW3.Address.to_checksum/1 instead."
   @doc "Returns a checksummed address conforming to EIP-55"
   @spec to_checksum_address(String.t()) :: String.t()
   def to_checksum_address(address) do
-    address = address |> String.downcase() |> String.replace(~r/^0x/, "")
-    hash_bin = ExKeccak.hash_256(address)
-
-    hash =
-      hash_bin
-      |> Base.encode16(case: :lower)
-      |> String.replace(~r/^0x/, "")
-
-    keccak_hash_list =
-      hash
-      |> String.split("", trim: true)
-      |> Enum.map(fn x -> elem(Integer.parse(x, 16), 0) end)
-
-    list_arr =
-      for n <- 0..(String.length(address) - 1) do
-        number = Enum.at(keccak_hash_list, n)
-
-        cond do
-          number >= 8 -> String.upcase(String.at(address, n))
-          true -> String.downcase(String.at(address, n))
-        end
-      end
-
-    "0x" <> List.to_string(list_arr)
+    address
+    |> Address.from_hex()
+    |> Address.to_checksum()
   end
 
+  @deprecated "Use ExW3.Address.is_valid_checksum?/1 instead."
   @doc "Checks if the address is a valid checksummed address"
   @spec is_valid_checksum_address(String.t()) :: boolean
   def is_valid_checksum_address(address) do
-    ExW3.Utils.to_checksum_address(address) == address
+    Address.is_valid_checksum?(address)
   end
 
   @doc "converts Ethereum style bytes to string"
@@ -139,9 +122,12 @@ defmodule ExW3.Utils do
     |> :binary.decode_unsigned()
   end
 
+  @deprecated "Use ExW3.Address.to_hex/1 instead."
   @doc "Converts bytes to Ethereum address"
   @spec to_address(binary()) :: binary()
   def to_address(bytes) do
-    Enum.join(["0x", bytes |> Base.encode16(case: :lower)], "")
+    bytes
+    |> Address.from_bytes()
+    |> Address.to_hex()
   end
 end

test/exw3/address_test.exs

@@ -0,0 +1,47 @@
+defmodule ExW3.AddressTest do
+  use ExUnit.Case
+  alias ExW3.Address
+
+  @bytes_address <<25, 154, 209, 226, 223, 37, 243, 29, 135, 172, 137, 205, 225, 158, 82, 44, 130, 62, 90, 166, 30>>
+  @string_address "199ad1e2df25f31d87ac89cde19e522c823e5aa61e"
+  @hex_address "0x199ad1e2df25f31d87ac89cde19e522c823e5aa61e"
+  @checksum_address "0x199ad1E2dF25f31D87AC89cdE19E522c823E5AA61e"
+
+  test ".from_bytes/1 returns an address struct" do
+    address = Address.from_bytes(@bytes_address)
+    assert address.bytes == @bytes_address
+  end
+
+  test ".from_hex/1 returns an address struct with and without the checksum" do
+    address = Address.from_hex(@hex_address)
+    assert address.bytes == @bytes_address
+
+    from_checksum_address = Address.from_hex(@checksum_address)
+    assert from_checksum_address.bytes == @bytes_address
+  end
+
+  test ".to_bytes/1 returns the bytes of the address struct" do
+    address = %Address{bytes: @bytes_address}
+    assert Address.to_bytes(address) == @bytes_address
+  end
+
+  test ".to_string/1 returns the hex encoded string without a 0x prefix" do
+    address = %Address{bytes: @bytes_address}
+    assert Address.to_string(address) == @string_address
+  end
+
+  test ".to_hex/1 returns the hex encoded string with a 0x prefix" do
+    address = %Address{bytes: @bytes_address}
+    assert Address.to_hex(address) == @hex_address
+  end
+
+  test ".to_checksum/1 returns the hex encoded string with a 0x prefix conforming to EIP-55" do
+    address = %Address{bytes: @bytes_address}
+    assert Address.to_checksum(address) == @checksum_address
+  end
+
+  test ".is_valid_checksum?/1 is true when it conforms to EIP-55" do
+    assert Address.is_valid_checksum?(@checksum_address) == true
+    assert Address.is_valid_checksum?(@hex_address) == false
+  end
+end

test/exw3_test.exs

@@ -332,7 +332,7 @@ defmodule ExW3Test do
 
     {:ok, same_address} = ExW3.Contract.call(:AddressTester, :get, [formatted_address])
 
-    assert ExW3.Utils.to_address(same_address) == Enum.at(context[:accounts], 0)
+    assert %ExW3.Address{bytes: same_address} |> ExW3.Address.to_hex() == Enum.at(context[:accounts], 0)
   end
 
   test "returns proper error messages at contract deployment", context do