Merge branch 'Testing' of github.com:lambdaclass/ethereum_war_game_tooling into Testing

Author: mmsc2

.gitignore

@@ -1,2 +1,3 @@
 cache/
 out/
+.local/

README.md

@@ -17,6 +17,26 @@ You can change any of these config values at runtime by using the functions expo
 
 The default config assumes you're running the local ethereum network this repo provides.
 
+If you want to use infura-type host this are the setps you must follow:
+
+First set your infura api key
+
+```
+Context.set_infura_api_key("your_infura_api_key")
+```
+
+Then set the your etherscan api key
+
+```
+Context.set_etherscan_api_key("your_eth_scan_api_key")
+```
+
+And finally set the name of the chain you want to use, for now this are the supported chains: eht mainnet, rinkeby and ropsten.
+
+```
+EthClient.set_chain("chain_name")
+```
+
 ### Interacting with smart contracts
 
 Currently there are three functions in the `EthClient` module that form the main API:

geth_nodes/docker-compose.yml renamed to docker-compose.yml

@@ -14,13 +14,14 @@ services:
       --verbosity 5 --allow-insecure-unlock --fakepow --http.api eth,web3,personal,admin
       --unlock 0xafb72ccaeb7e22c8a7640f605824b0898424b3da
       --password /root/private_network/password
+      --http.vhosts=*
     hostname: ethereum
     image: ethereum/client-go:stable
     ports:
     - 30304:30304
     - 8545:8545
     volumes:
-    - ./private_network:/root/private_network
+    - ./geth_nodes/private_network:/root/private_network
 
   ethereum_node2:
     command: --datadir /root/private_network/node2 --networkid 1234 --port 30305
@@ -30,10 +31,40 @@ services:
       --verbosity 5 --allow-insecure-unlock --fakepow --http.api eth,web3,personal,admin
       --unlock 0x77b648683cde1d69544ed6f4f7204e8d51c324db
       --password /root/private_network/password
+      --http.vhosts=*
     hostname: ethereum
     image: ethereum/client-go:stable
     ports:
     - 30305:30305
     - 8546:8546
     volumes:
-    - ./private_network:/root/private_network
+    - ./geth_nodes/private_network:/root/private_network
+
+  # ----------------------------------------------------------------------------
+  # Wargame Tooling Client
+  # ----------------------------------------------------------------------------
+
+  eth_client:
+    build: ./eth_client/
+    stdin_open: true # docker run -i
+    tty: true        # docker run -t
+    ports:
+      - 43487:43487
+    volumes:
+      - ./eth_client/:/app/
+
+  # ----------------------------------------------------------------------------
+  # Livebook Frontend
+  # ----------------------------------------------------------------------------
+  
+  livebook:
+    image: livebook/livebook
+    ports:
+      - 8080:8080
+      - 8081:8081
+    volumes:
+      - ./livebooks/:/home/livebook/
+    environment:
+      - LIVEBOOK_HOME=/home/livebook/
+      - LIVEBOOK_TOKEN_ENABLED=false
+      - LIVEBOOK_DEFAULT_RUNTIME=attached:eth_client@eth_client:mycookie

eth_client/.iex.exs

@@ -1,10 +1,11 @@
+alias EthClient
 alias EthClient.Context
 alias EthClient.Contract
 
 bin_path = "../contracts/src/bin/Storage.bin"
 abi_path = "../contracts/src/bin/Storage.abi"
 
 # Uncomment and fill in for Rinkeby
-# Context.set_rpc_host("your_rinkeby_rpc_host_here")
-# Context.set_chain_id(4)
-# Context.set_etherscan_api_key("your_api_key_here")
+Context.set_infura_api_key("your_infura_api_key")
+Context.set_etherscan_api_key("your_eth_scan_api_key")
+EthClient.set_chain("rinkeby")

eth_client/Dockerfile

@@ -0,0 +1,29 @@
+FROM elixir:1.13-alpine
+
+RUN apk --no-cache add \
+  cargo
+  # inotify-tools\
+  # git
+
+RUN mkdir /app
+WORKDIR /app
+
+RUN mix local.hex --force && mix local.rebar --force
+
+COPY mix.lock mix.exs ./
+
+# Get both dev and test env dependencies
+RUN MIX_ENV="dev" mix do deps.get --only dev, deps.compile
+# RUN MIX_ENV="test" mix do deps.get --only test, deps.compile
+
+# Copy the source code to the docker image.
+COPY . .
+
+# Pre-compile dev & test environments
+RUN MIX_ENV="dev" mix compile
+# RUN MIX_ENV="test" mix compile
+
+ENTRYPOINT "./startup.sh"
+CMD iex -S mix
+# CMD iex --sname wargame_tools --erl "-config sys.config -setcookie mycookie" -S mix
+

eth_client/lib/eth_client.ex

@@ -13,6 +13,13 @@ defmodule EthClient do
     4 => "rinkeby."
   }
 
+  @supported_chains ["ropsten", "rinkeby", "mainnet"]
+
+  @chain_id_by_name %{"mainnet" => 1, "ropsten" => 3, "rinkeby" => 4}
+
+  @local_host_chain_id 1234
+  @local_host_rpc "http://localhost:8545"
+  
   def deploy(bin_path) do
     {:ok, data} = File.read(bin_path)
     data = add_0x(data)
@@ -80,7 +87,7 @@ defmodule EthClient do
     wei_to_ether(balance)
   end
 
-  def invoke(method, arguments, amount) do
+  def invoke(method, arguments, amount \\ 0) do
     data =
       ABI.encode(method, arguments)
       |> Base.encode16(case: :lower)
@@ -134,6 +141,21 @@ defmodule EthClient do
     end
   end
 
+  def set_chain(chain_name) when chain_name in @supported_chains do
+    infura_api_key = Context.infura_api_key()
+    Context.set_rpc_host("https://#{chain_name}.infura.io/v3/#{infura_api_key}")
+    Context.set_chain_id(@chain_id_by_name[chain_name])
+  end
+
+  def set_chain("local") do
+    Context.set_rpc_host(@local_host_rpc)
+    Context.set_chain_id(@local_host_chain_id)
+  end
+
+  def set_chain(chain_name) do
+    Logger.info("#{chain_name} is not a supported chain.")
+  end
+
   defp nonce(address) do
     {nonce, ""} =
       Rpc.get_transaction_count(address)

eth_client/lib/eth_client/context.ex

@@ -17,11 +17,13 @@ defmodule EthClient.Context do
   def contract, do: get(:contract)
   def etherscan_api_key, do: get(:etherscan_api_key)
   def net_proxy, do: get(:net_proxy)
+  def infura_api_key, do: get(:infura_api_key)
 
   def set_rpc_host(new_host), do: set(:rpc_host, new_host)
   def set_chain_id(new_chain_id), do: set(:chain_id, new_chain_id)
   def set_user_account(new_user_account), do: set(:user_account, new_user_account)
   def set_net_proxy(proxy), do: set(:net_proxy, proxy)
+  def set_infura_api_key(api_key), do: set(:infura_api_key, api_key)
 
   def set_contract_address(new_address) do
     IEx.configure(default_prompt: "#{String.slice(new_address, 0..5)}>")

eth_client/lib/eth_client/contract.ex

@@ -2,6 +2,8 @@ defmodule EthClient.Contract do
   @moduledoc false
 
   alias EthClient.ABI
+  alias EthClient.Contract.Opcodes
+  alias EthClient.Rpc
 
   defstruct [:address, :functions]
 
@@ -13,6 +15,17 @@ defmodule EthClient.Contract do
     end
   end
 
+  def to_opcodes do
+    EthClient.Context.contract().address
+    |> contract_to_opcodes()
+  end
+
+  def contract_to_opcodes(address) when is_binary(address) do
+    with {:ok, code} <- Rpc.get_code(address) do
+      Opcodes.bytecode_to_opcodes(code)
+    end
+  end
+
   defp parse_abi(abi), do: parse_abi(abi, %{})
 
   defp parse_abi([], acc), do: {:ok, acc}

eth_client/lib/eth_client/contract/opcodes.ex

@@ -0,0 +1,82 @@
+defmodule EthClient.Contract.Opcodes do
+  alias EthClient.Rpc
+
+  @moduledoc """
+   This module provides a function to turn any valid EVM byte code
+   into opcodes and a function to retrieve a contract and turn it into
+   its opcodes.
+  """
+  def bytecode_to_opcodes(code) when is_binary(code) do
+    parse_code(code, [])
+  end
+
+  defp get_opcodes do
+    opcodes_from_file!()
+    |> parse_opcodes()
+  end
+
+  defp opcodes_from_file! do
+    "./opcodes.json"
+    |> Path.expand()
+    |> File.read!()
+  end
+
+  defp parse_opcodes(codes) do
+    codes
+    |> Jason.decode!()
+    |> filter_invalid()
+  end
+
+  defp filter_invalid(code_list) do
+    Enum.reduce(code_list, fn
+      %{"Hex" => _hex, "Name" => name}, acc when name == "*invalid*" -> acc
+      %{"Hex" => hex, "Name" => name}, acc -> Map.put(acc, hex, name)
+    end)
+  end
+
+  # First remove the leading 0x,
+  # upcase to keep it consistent with the JSON.
+  defp parse_code(<<"0x", rest::binary>>, []) do
+    rest
+    |> String.upcase()
+    |> parse_code([], get_opcodes())
+  end
+
+  # Opcodes are base16 numbers ranging from
+  # 00 up to FF, they come inside a string,
+  # so we match them every 2 characters and
+  # check the instruction matching those two characters
+  # Let's say we have FFAAFF, this function clause
+  # would match like this:
+  # opcode = "FF"
+  # rest = "AAFF"
+  # And FF matches with the "SELFDESTRUCT" instruction.
+  defp parse_code(<<opcode::binary-size(2), rest::binary>>, acum, opcodes) do
+    case Map.get(opcodes, opcode) do
+      nil ->
+        parse_code(rest, ["#{opcode} opcode is unknown" | acum], opcodes)
+
+      <<"PUSH", n::binary>> ->
+        {arguments, rest} = fetch_arguments(rest, n, :push)
+        parse_code(rest, ["PUSH 0x#{arguments}" | acum], opcodes)
+
+      instruction ->
+        parse_code(rest, [instruction | acum], opcodes)
+    end
+  end
+
+  # When this matches, we have finished parsing the string.
+  defp parse_code(_, acum, _) do
+    acum
+    |> Enum.reverse()
+    |> Enum.with_index(fn string, index -> "[#{index}] " <> string end)
+    |> Enum.join("\n")
+    |> IO.puts()
+  end
+
+  defp fetch_arguments(code, n, :push) when is_binary(n) do
+    chars_to_fetch = String.to_integer(n) * 2
+    <<arguments::binary-size(chars_to_fetch), rest::binary>> = code
+    {arguments, rest}
+  end
+end

eth_client/lib/eth_client/rpc.ex

@@ -17,6 +17,7 @@ defmodule EthClient.Rpc do
   def gas_price, do: send_request("eth_gasPrice", [])
   def get_transaction_by_hash(tx_hash), do: send_request("eth_getTransactionByHash", [tx_hash])
   def get_transaction_receipt(tx_hash), do: send_request("eth_getTransactionReceipt", [tx_hash])
+  def get_code(contract), do: send_request("eth_getCode", [contract, "latest"])
   def call(call_map), do: send_request("eth_call", [call_map, "latest"])
 
   def get_logs(log_map), do: send_request("eth_getLogs", [log_map])

eth_client/mix.exs

@@ -31,7 +31,7 @@ defmodule EthClient.MixProject do
       {:rustler, "~> 0.25.0"},
       {:ex_rlp, "~> 0.5.4"},
       {:dialyxir, "~> 1.1", only: [:dev, :test], runtime: false},
-      {:excoveralls, "~> 0.14.5"}
+      {:excoveralls, "~> 0.14.5", only: [:test], runtime: false}
     ]
   end
 end