setter modules renamed to builder for clarity

lib/eth.ex

@@ -54,25 +54,19 @@ defmodule ETH do
   defdelegate parse(data), to: ETH.Transaction.Parser
   defdelegate to_list(data), to: ETH.Transaction.Parser
 
-  defdelegate set(params), to: ETH.Transaction.Setter
-  defdelegate set(wallet, params), to: ETH.Transaction.Setter
-  defdelegate set(sender_wallet, receiver_wallet, params_or_value), to: ETH.Transaction.Setter
+  defdelegate build(params), to: ETH.Transaction.Builder
+  defdelegate build(wallet, params), to: ETH.Transaction.Builder
+  defdelegate build(sender_wallet, receiver_wallet, params_or_value), to: ETH.Transaction.Builder
 
-  defdelegate hash_transaction(transaction), to: ETH.Transaction.Signer
-  defdelegate hash_transaction(transaction, include_signature), to: ETH.Transaction.Signer
-  defdelegate hash_transaction_list(transaction_list), to: ETH.Transaction.Signer
-
-  defdelegate hash_transaction_list(transaction_list, include_signature),
-    to: ETH.Transaction.Signer
+  defdelegate hash(transaction), to: ETH.Transaction
+  defdelegate hash(transaction, include_signature), to: ETH.Transaction
 
   defdelegate sign_transaction(transaction, private_key), to: ETH.Transaction.Signer
   defdelegate sign_transaction_list(transaction_list, private_key), to: ETH.Transaction.Signer
   defdelegate decode(rlp_encoded_transaction), to: ETH.Transaction.Signer
   defdelegate encode(signed_transaction_list), to: ETH.Transaction.Signer
 
-  defdelegate hash(transaction, include_signature), to: ETH.Transaction
   defdelegate send_transaction(params_or_wallet, private_key_or_params), to: ETH.Transaction
-
   defdelegate send_transaction(sender_wallet, receiver_wallet, value_or_params),
     to: ETH.Transaction
 

lib/eth/query.ex

@@ -154,7 +154,7 @@ defmodule ETH.Query do
   def estimate_gas(transaction = %{to: _to, data: _data}, denomination) do
     case HttpClient.eth_estimate_gas(transaction) do
       {:ok, hex_gas_estimate} ->
-        {:ok, hex_gas_estimate |> convert_to_number |> convert(denomination)}
+        {:ok, hex_gas_estimate |> convert_to_number |> convert(denomination) |> round}
 
       error ->
         error
@@ -166,7 +166,7 @@ defmodule ETH.Query do
   def estimate_gas!(transaction = %{to: _to, data: _data}, denomination) do
     {:ok, hex_gas_estimate} = HttpClient.eth_estimate_gas(transaction)
 
-    hex_gas_estimate |> convert_to_number |> convert(denomination)
+    hex_gas_estimate |> convert_to_number |> convert(denomination) |> round
   end
 
   defp get_result({:ok, eth_result}), do: Map.get(eth_result, "result")

lib/eth/transaction.ex

@@ -4,32 +4,18 @@ defmodule ETH.Transaction do
   defdelegate parse(data), to: ETH.Transaction.Parser
   defdelegate to_list(data), to: ETH.Transaction.Parser
 
-  defdelegate set(params), to: ETH.Transaction.Setter
-  defdelegate set(wallet, params), to: ETH.Transaction.Setter
-  defdelegate set(sender_wallet, receiver_wallet, params_or_value), to: ETH.Transaction.Setter
+  defdelegate build(params), to: ETH.Transaction.Builder
+  defdelegate build(wallet, params), to: ETH.Transaction.Builder
+  defdelegate build(sender_wallet, receiver_wallet, params_or_value), to: ETH.Transaction.Builder
 
-  defdelegate hash_transaction(transaction), to: ETH.Transaction.Signer
-  defdelegate hash_transaction(transaction, include_signature), to: ETH.Transaction.Signer
-  defdelegate hash_transaction_list(transaction_list), to: ETH.Transaction.Signer
-
-  defdelegate hash_transaction_list(transaction_list, include_signature),
-    to: ETH.Transaction.Signer
+  defdelegate hash(transaction), to: ETH.Transaction.Signer
+  defdelegate hash(transaction, include_signature), to: ETH.Transaction.Signer
 
   defdelegate sign_transaction(transaction, private_key), to: ETH.Transaction.Signer
   defdelegate sign_transaction_list(transaction_list, private_key), to: ETH.Transaction.Signer
   defdelegate decode(rlp_encoded_transaction), to: ETH.Transaction.Signer
   defdelegate encode(signed_transaction_list), to: ETH.Transaction.Signer
 
-  def hash(transaction, include_signature \\ true)
-
-  def hash(transaction, include_signature) when is_list(transaction) do
-    ETH.Transaction.Signer.hash_transaction_list(transaction, include_signature)
-  end
-
-  def hash(transaction = %{}, include_signature) do
-    ETH.Transaction.Signer.hash_transaction(transaction, include_signature)
-  end
-
   def send_transaction(wallet, params) when is_map(params) do
     params
     |> Map.merge(%{from: wallet.eth_address})
@@ -156,7 +142,7 @@ defmodule ETH.Transaction do
            s
          ]
        ) do
-    message_hash = hash_transaction_list(transaction_list, false)
+    message_hash = hash(transaction_list, false)
     chain_id = get_chain_id(v, Enum.at(transaction_list, 9))
     v_int = buffer_to_int(v)
     target_v = if chain_id > 0, do: v_int - (chain_id * 2 + 8), else: v_int
@@ -175,7 +161,7 @@ defmodule ETH.Transaction do
 
     result =
       target_params
-      |> set
+      |> build
       |> sign_transaction(private_key)
       |> Base.encode16()
       |> send

lib/eth/transaction/setter.ex → lib/eth/transaction/builder.ex

@@ -1,61 +1,63 @@
-defmodule ETH.Transaction.Setter do
+require IEx
+
+defmodule ETH.Transaction.Builder do
   import ETH.Transaction.Parser
 
-  def set(params) when is_list(params) do
+  def build(params) when is_list(params) do
     params
-    |> set_params_from_list
+    |> build_params_from_list
     |> parse
   end
 
-  def set(params) when is_map(params) do
+  def build(params) when is_map(params) do
     params
-    |> set_params_from_map
+    |> build_params_from_map
     |> parse
   end
 
-  def set(wallet, params) do
+  def build(wallet, params) do
     result =
       cond do
         is_map(params) ->
           target_params = params |> Map.merge(%{from: wallet.eth_address})
-          set_params_from_map(target_params)
+          build_params_from_map(target_params)
 
         is_list(params) ->
           target_params = params |> Keyword.merge(from: wallet.eth_address)
-          set_params_from_list(target_params)
+          build_params_from_list(target_params)
       end
 
     parse(result)
   end
 
-  def set(sender_wallet, receiver_wallet, value) when is_number(value) do
+  def build(sender_wallet, receiver_wallet, value) when is_number(value) do
     %{from: sender_wallet.eth_address, to: receiver_wallet.eth_address, value: value}
-    |> set_params_from_map
+    |> build_params_from_map
     |> parse
   end
 
-  def set(sender_wallet, receiver_wallet, params) do
+  def build(sender_wallet, receiver_wallet, params) do
     result =
       cond do
         is_map(params) ->
           target_params =
             params
             |> Map.merge(%{from: sender_wallet.eth_address, to: receiver_wallet.eth_address})
 
-          set_params_from_map(target_params)
+          build_params_from_map(target_params)
 
         is_list(params) ->
           target_params =
             params
             |> Keyword.merge(from: sender_wallet.eth_address, to: receiver_wallet.eth_address)
 
-          set_params_from_list(target_params)
+          build_params_from_list(target_params)
       end
 
     parse(result)
   end
 
-  defp set_params_from_list(params) do
+  defp build_params_from_list(params) do
     to = Keyword.get(params, :to, "")
     value = Keyword.get(params, :value, 0)
     gas_price = Keyword.get(params, :gas_price, ETH.gas_price!())
@@ -79,7 +81,7 @@ defmodule ETH.Transaction.Setter do
     %{nonce: nonce, gas_price: gas_price, gas_limit: gas_limit, to: to, value: value, data: data}
   end
 
-  defp set_params_from_map(params) do
+  defp build_params_from_map(params) do
     to = Map.get(params, :to, "")
     value = Map.get(params, :value, 0)
     gas_price = Map.get(params, :gas_price, ETH.gas_price!())

lib/eth/transaction/signer.ex

@@ -3,34 +3,15 @@ defmodule ETH.Transaction.Signer do
 
   alias ETH.Transaction.Parser, as: TransactionParser
 
-  def hash_transaction(transaction, include_signature \\ true)
-
-  def hash_transaction(
-        transaction = %{
-          to: _to,
-          value: _value,
-          data: _data,
-          gas_price: _gas_price,
-          gas_limit: _gas_limit,
-          nonce: _nonce
-        },
-        include_signature
-      ) do
-    chain_id = get_chain_id(Map.get(transaction, :v, <<28>>), Map.get(transaction, :chain_id))
+  def decode(<<rlp_encoded_transaction_list>>), do: ExRLP.decode(rlp_encoded_transaction_list)
 
-    transaction
-    |> Map.delete(:chain_id)
-    |> TransactionParser.to_list()
-    |> List.insert_at(-1, chain_id)
-    |> hash_transaction_list(include_signature)
+  def encode(transaction_list = [_nonce, _gas_price, _gas_limit, _to, _value, _data, _v, _r, _s]) do
+    ExRLP.encode(transaction_list)
   end
 
-  # NOTE: usage is generally internal
-  def hash_transaction_list(
-        transaction_list,
-        include_signature \\ true
-      )
-      when is_list(transaction_list) do
+  def hash(transaction, include_signature \\ true)
+
+  def hash(transaction_list, include_signature) when is_list(transaction_list) do
     target_list =
       case include_signature do
         true ->
@@ -52,10 +33,24 @@ defmodule ETH.Transaction.Signer do
     |> keccak256
   end
 
-  def decode(<<rlp_encoded_transaction_list>>), do: ExRLP.decode(rlp_encoded_transaction_list)
+  def hash(
+        transaction = %{
+          to: _to,
+          value: _value,
+          data: _data,
+          gas_price: _gas_price,
+          gas_limit: _gas_limit,
+          nonce: _nonce
+        },
+        include_signature
+      ) do
+    chain_id = get_chain_id(Map.get(transaction, :v, <<28>>), Map.get(transaction, :chain_id))
 
-  def encode(transaction_list = [_nonce, _gas_price, _gas_limit, _to, _value, _data, _v, _r, _s]) do
-    ExRLP.encode(transaction_list)
+    transaction
+    |> Map.delete(:chain_id)
+    |> TransactionParser.to_list()
+    |> List.insert_at(-1, chain_id)
+    |> hash(include_signature)
   end
 
   def sign_transaction(transaction, private_key) when is_map(transaction) do
@@ -115,7 +110,7 @@ defmodule ETH.Transaction.Signer do
          <<private_key::binary-size(32)>>
        ) do
     chain_id = get_chain_id(v, Enum.at(transaction_list, 9))
-    message_hash = hash_transaction_list(transaction_list, false)
+    message_hash = hash(transaction_list, false)
 
     [signature: signature, recovery: recovery] = secp256k1_signature(message_hash, private_key)
 

lib/eth/wallet.ex

@@ -1,3 +1,4 @@
+# NOTE: maybe do HD Wallets + create(mnemonic phrase)
 defmodule ETH.Wallet do
   import ETH.Utils
 

test/eth/eth_test.exs

@@ -6,6 +6,9 @@ defmodule ETH.Test do
              block_number: 0,
              block_number!: 0,
              buffer_to_int: 1,
+             build: 1,
+             build: 2,
+             build: 3,
              call: 1,
              call!: 1,
              convert: 2,
@@ -45,11 +48,8 @@ defmodule ETH.Test do
              get_transaction_from_block: 2,
              get_transaction_from_block!: 2,
              get_transaction_receipt: 1,
+             hash: 1,
              hash: 2,
-             hash_transaction: 1,
-             hash_transaction: 2,
-             hash_transaction_list: 1,
-             hash_transaction_list: 2,
              keccak256: 1,
              pad_to_even: 1,
              parse: 1,
@@ -58,9 +58,6 @@ defmodule ETH.Test do
              send_transaction: 2,
              send_transaction: 3,
              send_transaction: 4,
-             set: 1,
-             set: 2,
-             set: 3,
              sign_transaction: 2,
              sign_transaction_list: 2,
              syncing: 0,