Add function to get ABI from non-etherscan addresses

eth_client/lib/eth_client.ex

@@ -86,6 +86,21 @@ defmodule EthClient do
     |> Rpc.call()
   end
 
+  def call_by_selector(selector, arguments) do
+    encoded_arguments =
+      ABI.TypeEncoder.encode_raw(arguments, selector.types)
+      |> Base.encode16(case: :lower)
+
+    data = selector.method_id <> encoded_arguments
+
+    %{
+      from: Context.user_account().address,
+      to: Context.contract().address,
+      data: data
+    }
+    |> Rpc.call()
+  end
+
   def get_balance(address) do
     {balance, _lead} =
       Rpc.get_balance(address)
@@ -95,12 +110,27 @@ defmodule EthClient do
     wei_to_ether(balance)
   end
 
+  def invoke_by_selector(selector, arguments, amount \\ 0) do
+    encoded_arguments =
+      ABI.TypeEncoder.encode_raw(arguments, selector.types)
+      |> Base.encode16(case: :lower)
+
+    data = selector.method_id <> encoded_arguments
+
+    invoke_with_data(data, amount)
+  end
+
   def invoke(method, arguments, amount \\ 0) do
     data =
-      ABI.encode(method, arguments)
+      method
+      |> ABI.encode(arguments)
       |> Base.encode16(case: :lower)
       |> add_0x()
 
+    invoke_with_data(data, amount)
+  end
+
+  defp invoke_with_data(data, amount) do
     caller = Context.user_account()
     caller_address = String.downcase(caller.address)
     contract_address = Context.contract().address

eth_client/lib/eth_client/abi.ex

@@ -1,10 +1,56 @@
 defmodule EthClient.ABI do
   @moduledoc false
   alias EthClient.Context
+  alias EthClient.Rpc
+
+  # get whether it's an etherscan-linked bc: get_etherscan_api_key...
+  def get("0x" <> _ = address) do
+    if Context.etherscan_api_key() do
+      get_etherscan(address)
+    else
+      get_non_etherscan(address)
+    end
+  end
 
-  def get("0x" <> _ = address), do: get_etherscan(address)
   def get(abi_path), do: get_local(abi_path)
 
+  def to_selector(function_def) do
+    function_def["name"]
+    |> ABI.FunctionSelector.decode()
+    |> Map.put(:method_id, function_def["selector"])
+    |> Map.put(:state_mutability, function_def["stateMutability"])
+  end
+
+  defp filter_unnamed(function_def) do
+    "0x" <> function_hash = function_def.method_id
+    unknown_name = "unknown" <> function_hash
+
+    case Map.get(function_def, :function) do
+      ^unknown_name -> Map.delete(function_def, :function)
+      _ -> function_def
+    end
+  end
+
+  def get_non_etherscan(address) do
+    decode_path = Application.app_dir(:eth_client, "priv/decompile.py")
+    {:ok, bytecode} = Rpc.get_code(address)
+
+    case System.cmd("python3", [decode_path, bytecode]) do
+      {hashes, 0} ->
+        funclist =
+          hashes
+          |> Jason.decode!()
+          |> Enum.filter(fn %{"selector" => hash} -> hash != "_fallback()" end)
+          |> Enum.map(&to_selector/1)
+          |> Enum.map(&filter_unnamed/1)
+
+        {:ok, funclist}
+
+      {_, _} ->
+        {:error, :abi_unavailable}
+    end
+  end
+
   defp get_etherscan(address) do
     api_key = Context.etherscan_api_key()
 

eth_client/lib/eth_client/contract.ex

@@ -57,26 +57,85 @@ defmodule EthClient.Contract do
 
   defp parse_abi([], acc), do: {:ok, acc}
 
-  defp parse_abi([%{"type" => "function"} = method_map | tail], acc) do
+  defp parse_abi([%{"type" => "function", "name" => name} = method_map | tail], acc) do
     method = %{
-      name: String.to_atom(method_map["name"]),
+      name: name,
       state_mutability: method_map["stateMutability"],
       inputs: Enum.map(method_map["inputs"], fn input -> input["name"] end),
       # What's the difference between type and internal type?
       input_types: Enum.map(method_map["inputs"], fn input -> input["internalType"] end)
     }
 
-    name_snake_case = String.to_atom(Macro.underscore(method_map["name"]))
+    name_snake_case = String.to_atom(Macro.underscore(name))
     function = build_function(method)
     acc = Map.put(acc, name_snake_case, Code.eval_quoted(function) |> elem(0))
 
     parse_abi(tail, acc)
   end
 
+  defp parse_abi([%{function: name} = method_map | tail], acc) do
+    function = build_function_by_hash(method_map)
+
+    selector_atom =
+      name
+      |> Macro.underscore()
+      |> String.to_atom()
+
+    {term, _bind} = Code.eval_quoted(function)
+    acc = Map.put(acc, selector_atom, term)
+
+    parse_abi(tail, acc)
+  end
+
+  defp parse_abi([%{type: _function, method_id: selector} = method_map | tail], acc) do
+    function = build_function_by_hash(method_map)
+
+    selector_atom =
+      selector
+      |> String.to_atom()
+
+    {term, _bind} = Code.eval_quoted(function)
+    acc = Map.put(acc, selector_atom, term)
+
+    parse_abi(tail, acc)
+  end
+
   defp parse_abi([_head | tail], acc) do
     parse_abi(tail, acc)
   end
 
+  defp build_function_by_hash(%{state_mutability: mutability} = method)
+       when mutability in ["pure", "view"] do
+    args =
+      method.types
+      |> length()
+      |> Macro.generate_arguments(__MODULE__)
+
+    bound_method = Macro.escape(method)
+
+    quote do
+      fn unquote_splicing(args) ->
+        EthClient.call_by_selector(unquote(bound_method), unquote(args))
+      end
+    end
+  end
+
+  defp build_function_by_hash(%{method_id: _selector} = method) do
+    args =
+      method
+      |> Map.get(:types)
+      |> length()
+      |> Macro.generate_arguments(__MODULE__)
+
+    bound_method = Macro.escape(method)
+
+    quote do
+      fn unquote_splicing(args), amount ->
+        EthClient.invoke_by_selector(unquote(bound_method), unquote(args), amount)
+      end
+    end
+  end
+
   defp build_function(%{state_mutability: mutability} = method)
        when mutability in ["pure", "view"] do
     args = Macro.generate_arguments(length(method.inputs), __MODULE__)

eth_client/priv/decompile.py

@@ -0,0 +1,28 @@
+import sys
+import json
+from panoramix.decompiler import decompile_bytecode
+
+def get_hash(function_def):
+    func = {}
+    func['selector'] = function_def['hash']
+    func['name'] = function_def['abi_name']
+
+    if function_def['payable']:
+        # This needs some work
+        func['stateMutability'] = "payable"
+    else: 
+        func['stateMutability'] = "nonpayable"
+    if function_def['const']:
+        func['stateMutability'] = "view"
+
+    func['type'] = "function"
+
+    return func
+
+if len(sys.argv) != 2:
+    print("usage: python3 decode_address.py <address>", sys.argv)
+else:
+    decompilation = decompile_bytecode(sys.argv[1])
+    # Despite its name, it's not a json
+    hashes = list(map(get_hash, decompilation.json["functions"]))
+    print(json.dumps(hashes))