defmodule Web3.Type.Address do
@moduledoc """
The address (40 (hex) characters / 160 bits / 20 bytes) is derived from the public key (128 (hex) characters /
512 bits / 64 bytes) which is derived from the private key (64 (hex) characters / 256 bits / 32 bytes).
The address is actually the last 40 characters of the keccak-256 hash of the public key with `0x` appended.
Copy from [Blockscout](https://github.com/blockscout/blockscout)
"""
alias Web3.Type.Hash
use Ecto.Type
@behaviour Hash
@byte_count 20
@hexadecimal_digit_count Hash.hexadecimal_digits_per_byte() * @byte_count
@typedoc """
A #{@byte_count}-byte hash of the address public key.
"""
@type t :: %Hash{
byte_count: unquote(@byte_count),
bytes: <<_::unquote(@byte_count * Hash.bits_per_byte())>>
}
@doc """
Casts `term` to `t:t/0`.
If the `term` is already in `t:t/0`, then it is returned
iex> Web3.Type.Address.cast(
...> %Web3.Type.Hash{
...> byte_count: 20,
...> bytes: <<0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed :: big-integer-size(20)-unit(8)>>
...> }
...> )
{
:ok,
%Web3.Type.Hash{
byte_count: 20,
bytes: <<0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed :: big-integer-size(20)-unit(8)>>
}
}
If the `term` is an `non_neg_integer`, then it is converted to `t:t/0`
iex> Web3.Type.Address.cast(0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed)
{
:ok,
%Web3.Type.Hash{
byte_count: 20,
bytes: <<0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed :: big-integer-size(20)-unit(8)>>
}
}
If the `non_neg_integer` is too large, then `:error` is returned.
iex> Web3.Type.Address.cast(0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b)
:error
If the `term` is a `String.t` that starts with `0x`, then is converted to an integer and then to `t:t/0`.
iex> Web3.Type.Address.cast("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed")
{
:ok,
%Web3.Type.Hash{
byte_count: 20,
bytes: <<0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed :: big-integer-size(20)-unit(8)>>
}
}
While `non_neg_integers` don't have to be the correct width (because zero padding it difficult with numbers),
`String.t` format must always have #{@hexadecimal_digit_count} digits after the `0x` base prefix.
iex> Web3.Type.Address.cast("0x0")
:error
"""
@impl Ecto.Type
@spec cast(term()) :: {:ok, t()} | :error
def cast(term) do
Hash.cast(__MODULE__, term)
end
@doc """
Dumps the binary hash to `:binary` (`bytea`) format used in database.
If the field from the struct is `t:t/0`, then it succeeds
iex> Web3.Type.Address.dump(
...> %Web3.Type.Hash{
...> byte_count: 20,
...> bytes: <<0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed :: big-integer-size(20)-unit(8)>>
...> }
...> )
{:ok, <<0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed :: big-integer-size(20)-unit(8)>>}
If the field from the struct is an incorrect format such as `t:Web3.Type.Hash.t/0`, `:error` is returned
iex> Web3.Type.Address.dump(
...> %Web3.Type.Hash{
...> byte_count: 32,
...> bytes: <<0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b ::
...> big-integer-size(32)-unit(8)>>
...> }
...> )
:error
"""
@impl Ecto.Type
@spec dump(term()) :: {:ok, binary} | :error
def dump(term) do
Hash.dump(__MODULE__, term)
end
@doc """
Loads the binary hash from the database.
If the binary hash is the correct format, it is returned.
iex> Web3.Type.Address.load(
...> <<0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed :: big-integer-size(20)-unit(8)>>
...> )
{
:ok,
%Web3.Type.Hash{
byte_count: 20,
bytes: <<0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed :: big-integer-size(20)-unit(8)>>
}
}
If the binary hash is an incorrect format, such as if an `Web3.Type.Hash` field is loaded, `:error` is returned.
iex> Web3.Type.Address.load(
...> <<0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b :: big-integer-size(32)-unit(8)>>
...> )
:error
"""
@impl Ecto.Type
@spec load(term()) :: {:ok, t} | :error
def load(term) do
Hash.load(__MODULE__, term)
end
@doc """
The underlying database type: `binary`. `binary` is used because no Postgres integer type is 20 bytes long.
"""
@impl Ecto.Type
@spec type() :: :binary
def type, do: :binary
@impl Hash
def byte_count, do: @byte_count
@doc """
Validates a hexadecimal encoded string to see if it conforms to an address.
## Error Descriptions
* `:invalid_characters` - String used non-hexadecimal characters
* `:invalid_checksum` - Mixed-case string didn't pass [EIP-55 checksum](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-55.md)
* `:invalid_length` - Addresses are expected to be 40 hex characters long
## Example
iex> Web3.Type.Address.validate("0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232d")
{:ok, "0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232d"}
iex> Web3.Type.Address.validate("0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232H")
{:error, :invalid_characters}
"""
@spec validate(String.t()) ::
{:ok, String.t()} | {:error, :invalid_length | :invalid_characters | :invalid_checksum}
def validate("0x" <> hash) do
with {:length, true} <- {:length, String.length(hash) == 40},
{:hex, true} <- {:hex, is_hex?(hash)},
{:mixed_case, true} <- {:mixed_case, is_mixed_case?(hash)},
{:checksummed, true} <- {:checksummed, is_checksummed?(hash)} do
{:ok, "0x" <> hash}
else
{:length, false} ->
{:error, :invalid_length}
{:hex, false} ->
{:error, :invalid_characters}
{:mixed_case, false} ->
{:ok, "0x" <> hash}
{:checksummed, false} ->
{:error, :invalid_checksum}
end
end
# @spec to_checksum(t) :: String.t()
# def to_checksum(address) do
# # address = address |> Web3.Type.Hash.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_checksummed?(String.t()) :: boolean()
def is_checksummed?(original_hash) do
lowercase_hash = String.downcase(original_hash)
sha3_hash = ExKeccak.hash_256(lowercase_hash)
do_checksum_check(sha3_hash, original_hash)
end
@spec is_hex?(String.t()) :: boolean()
defp is_hex?(hash) do
case Regex.run(~r|[0-9a-f]{40}|i, hash) do
nil -> false
[_] -> true
end
end
@spec is_mixed_case?(String.t()) :: boolean()
defp is_mixed_case?(hash) do
upper_check = ~r|[0-9A-F]{40}|
lower_check = ~r|[0-9a-f]{40}|
with nil <- Regex.run(upper_check, hash),
nil <- Regex.run(lower_check, hash) do
true
else
_ -> false
end
end
@spec do_checksum_check(binary(), String.t()) :: boolean()
defp do_checksum_check(_, ""), do: true
defp do_checksum_check(sha3_hash, address_hash) do
<<checksum_digit::integer-size(4), remaining_sha3_hash::bits>> = sha3_hash
<<current_char::binary-size(1), remaining_address_hash::binary>> = address_hash
if is_proper_case?(checksum_digit, current_char) do
do_checksum_check(remaining_sha3_hash, remaining_address_hash)
else
false
end
end
@spec is_proper_case?(integer, String.t()) :: boolean()
defp is_proper_case?(checksum_digit, character) do
case_map = %{
"0" => :both,
"1" => :both,
"2" => :both,
"3" => :both,
"4" => :both,
"5" => :both,
"6" => :both,
"7" => :both,
"8" => :both,
"9" => :both,
"a" => :lower,
"b" => :lower,
"c" => :lower,
"d" => :lower,
"e" => :lower,
"f" => :lower,
"A" => :upper,
"B" => :upper,
"C" => :upper,
"D" => :upper,
"E" => :upper,
"F" => :upper
}
character_case = Map.get(case_map, character)
# Digits with checksum digit greater than 7 should be uppercase
if checksum_digit > 7 do
character_case in ~w(both upper)a
else
character_case in ~w(both lower)a
end
end
end
