merge master

Author: adrienmo

apps/neo_node/config/config.exs

@@ -0,0 +1 @@
+use Mix.Config

apps/neoscan_node/coveralls.json apps/neo_node/coveralls.json

@@ -0,0 +1,110 @@
+defmodule NeoNode do
+  @moduledoc """
+  The boundary for the Blockchain requests.
+  """
+
+  require Logger
+  alias NeoNode.Parser
+  alias NeoNode.HTTPPoisonWrapper
+
+  @timeout 2_000
+
+  @opts [ssl: [{:versions, [:"tlsv1.2"]}], timeout: @timeout, recv_timeout: @timeout]
+  @headers [{"Content-Type", "application/json"}, {"Accept-Encoding", "gzip"}]
+
+  @gzip_header {"Content-Encoding", "gzip"}
+  @xgzip_header {"Content-Encoding", "x-gzip"}
+
+  @doc """
+   Get the current block by height through seed 'index'
+  """
+
+  def get_block_by_height(url, height) do
+    case post(url, "getblock", [height, 1]) do
+      {:ok, response} ->
+        {:ok, Parser.parse_block(response)}
+
+      error ->
+        error
+    end
+  end
+
+  def get_block_by_hash(url, hash) do
+    case post(url, "getblock", [hash, 1]) do
+      {:ok, response} ->
+        {:ok, Parser.parse_block(response)}
+
+      error ->
+        error
+    end
+  end
+
+  def get_block_count(url), do: post(url, "getblockcount", [])
+
+  def get_transaction(url, txid) do
+    case post(url, "getrawtransaction", [txid, 1]) do
+      {:ok, response} ->
+        {:ok, Parser.parse_transaction(response)}
+
+      error ->
+        error
+    end
+  end
+
+  def get_asset(url, txid) do
+    case post(url, "getassetstate", [txid, 1]) do
+      {:ok, response} ->
+        {:ok, Parser.parse_asset(response)}
+
+      error ->
+        error
+    end
+  end
+
+  def get_contract(url, hash) do
+    case post(url, "getcontractstate", [hash]) do
+      {:ok, response} ->
+        {:ok, Parser.parse_contract(response)}
+
+      error ->
+        error
+    end
+  end
+
+  def post(url, method, params) do
+    data =
+      Poison.encode!(%{
+        "jsonrpc" => "2.0",
+        "method" => method,
+        "params" => params,
+        "id" => 5
+      })
+
+    result = HTTPPoisonWrapper.post(url, data, @headers, @opts)
+    handle_response(result, url)
+  end
+
+  defp has_gzip_headers?(headers), do: @gzip_header in headers or @xgzip_header in headers
+
+  # Handles the response of an HTTP call
+  defp handle_response(
+         {:ok, %HTTPoison.Response{status_code: 200, body: body, headers: headers}},
+         _
+       ) do
+    body
+    |> (&if(has_gzip_headers?(headers), do: :zlib.gunzip(&1), else: &1)).()
+    |> Poison.decode()
+    |> handle_body()
+  end
+
+  defp handle_response({_, result}, url) do
+    message = "#{inspect(result)} #{url}"
+    Logger.debug(message)
+    {:error, message}
+  end
+
+  # handles a sucessful response
+  defp handle_body({:ok, %{"result" => result}}), do: {:ok, result}
+  defp handle_body({:ok, %{"error" => error}}), do: {:error, error}
+  defp handle_body(error), do: {:error, "body error: #{inspect(error)}"}
+end

apps/neo_node/lib/neo_node/neo_node.ex

@@ -1,4 +1,4 @@
-defmodule NeoscanNode.Parser do
+defmodule NeoNode.Parser do
   defp parse16("0x" <> rest), do: parse16(rest)
 
   defp parse16(string) do
@@ -25,7 +25,6 @@ defmodule NeoscanNode.Parser do
 
   defp parse_float(nil), do: nil
   defp parse_float(string), do: elem(Float.parse(string), 0)
-  defp parse_integer(string), do: String.to_integer(string)
 
   defp parse_claims(nil), do: []
   defp parse_claims(claims), do: Enum.map(claims, &parse_vin/1)
@@ -56,32 +55,6 @@ defmodule NeoscanNode.Parser do
     |> parse_asset()
   end
 
-  defp parse_notify_type("transfer"), do: :transfer
-
-  def parse_block_notification(block_notification = %{"notify_type" => "transfer"}) do
-    %{
-      addr_from: parse58(block_notification["addr_from"]),
-      addr_to: parse58(block_notification["addr_to"]),
-      amount: parse_integer(block_notification["amount"]),
-      block: block_notification["block"],
-      contract: parse16(block_notification["contract"]),
-      notify_type: parse_notify_type(block_notification["notify_type"]),
-      transaction_hash: parse16(block_notification["tx"]),
-      type: block_notification["type"]
-    }
-  end
-
-  def parse_block_notification(_) do
-    %{notify_type: :others}
-  end
-
-  def parse_contract(contract = %{"code" => code}) do
-    contract
-    |> Map.merge(code)
-    |> Map.delete("code")
-    |> parse_contract()
-  end
-
   def parse_contract(contract) do
     %{
       author: contract["author"],
@@ -168,26 +141,4 @@ defmodule NeoscanNode.Parser do
       if(is_nil(contract), do: [], else: [%{"contract" => contract}]) ++
       if is_nil(script), do: [], else: [%{"script" => script}]
   end
-
-  defp parse_token_token(token) do
-    %{
-      contract_address: parse58(token["contract_address"]),
-      decimals: token["decimals"],
-      name: parse_string(token["name"]),
-      script_hash: parse16(token["script_hash"]),
-      symbol: parse_string(token["symbol"])
-    }
-  end
-
-  def parse_token(token) do
-    %{
-      block: token["block"],
-      contract: parse_contract(token["contract"]),
-      token: parse_token_token(token["token"]),
-      transaction_hash: parse16(token["tx"]),
-      type: token["type"]
-    }
-  end
-
-  defp parse_string(string), do: String.replace(string, "\u0000", "")
 end

apps/neoscan_node/lib/neoscan_node/parser.ex apps/neo_node/lib/neo_node/parser.ex

@@ -0,0 +1,68 @@
+defmodule NeoNode.Mixfile do
+  use Mix.Project
+
+  def project do
+    [
+      app: :neo_node,
+      version: "2.0.0",
+      build_path: "../../_build",
+      config_path: "../../config/config.exs",
+      deps_path: "../../deps",
+      lockfile: "../../mix.lock",
+      elixir: "~> 1.6",
+      elixirc_options: [
+        warnings_as_errors: true
+      ],
+      elixirc_paths: elixirc_paths(Mix.env()),
+      test_coverage: [
+        tool: ExCoveralls
+      ],
+      preferred_cli_env: [
+        coveralls: :test,
+        "coveralls.detail": :test,
+        "coveralls.post": :test,
+        "coveralls.html": :test
+      ],
+      build_embedded: Mix.env() == :prod,
+      start_permanent: Mix.env() == :prod,
+      deps: deps()
+    ]
+  end
+
+  # Configuration for the OTP application
+  #
+  # Type "mix help compile.app" for more information
+  def application do
+    # Specify extra applications you'll use from Erlang/Elixir
+    [
+      extra_applications: [:logger, :httpoison]
+    ]
+  end
+
+  # Specifies which paths to compile per environment.
+  defp elixirc_paths(:test), do: ["lib", "test/support"]
+  defp elixirc_paths(_), do: ["lib", "wrapper"]
+
+  # Dependencies can be Hex packages:
+  #
+  #   {:my_dep, "~> 0.3.0"}
+  #
+  # Or git/path repositories:
+  #
+  #   {:my_dep, git: "https://github.com/elixir-lang/my_dep.git", tag: "0.1.0"}
+  #
+  # To depend on another app inside the umbrella:
+  #
+  #   {:my_app, in_umbrella: true}
+  #
+  # Type "mix help deps" for more examples and options
+  defp deps do
+    [
+      {:hackney, "~> 1.11", override: true},
+      {:poison, "~> 3.1"},
+      {:base58, github: "adrienmo/base58"},
+      {:httpoison, "~> 0.11 or ~> 0.12 or ~> 0.13"},
+      {:excoveralls, "~> 0.8", only: :test}
+    ]
+  end
+end

apps/neo_node/mix.exs

@@ -1,7 +1,12 @@
-defmodule Neoscan.Blockchain.BlockchainTest do
+defmodule NeoNodeTest do
   use ExUnit.Case
 
-  alias NeoscanNode.Blockchain
+  @fake_node_url "http://fakenode"
+
+  test "post/3" do
+    assert {:ok, _} = NeoNode.post(@fake_node_url, "getblock", [0, 1])
+    assert {:error, _} = NeoNode.post(@fake_node_url, "getblockerror", [0, 1])
+  end
 
   test "get_block_by_height/2" do
     assert {
@@ -179,26 +184,32 @@ defmodule Neoscan.Blockchain.BlockchainTest do
                ],
                version: 0
              }
-           } == Blockchain.get_block_by_height(0)
+           } == NeoNode.get_block_by_height(@fake_node_url, 0)
+
+    assert {:ok, %{index: 2_120_069}} = NeoNode.get_block_by_height(@fake_node_url, 2_120_069)
+
+    assert {:error, "error"} == NeoNode.get_block_by_height(@fake_node_url, 123_456)
 
-    assert {:ok, %{index: 2_120_069}} = Blockchain.get_block_by_height(2_120_069)
+    assert {:error, ":timeout #{@fake_node_url}"} ==
+             NeoNode.get_block_by_height(@fake_node_url, 123_457)
   end
 
   test "get_block_by_hash/2" do
     block_0_hash = "d42561e3d30e15be6400b6df2f328e02d2bf6354c41dce433bc57687c82144bf"
     block_1_hash = "d782db8a38b0eea0d7394e0f007c61c71798867578c77c387c08113903946cc9"
-    assert {:ok, %{index: 0}} = Blockchain.get_block_by_hash(block_0_hash)
-    assert {:ok, %{index: 1}} = Blockchain.get_block_by_hash(block_1_hash)
+    assert {:ok, %{index: 0}} = NeoNode.get_block_by_hash(@fake_node_url, block_0_hash)
+    assert {:ok, %{index: 1}} = NeoNode.get_block_by_hash(@fake_node_url, block_1_hash)
 
     assert {:error, %{"code" => -100, "message" => _message}} =
-             Blockchain.get_block_by_hash(
+             NeoNode.get_block_by_hash(
+               @fake_node_url,
                "0000000000000000000000000000000000000000000000000000000000000000"
              )
   end
 
   test "get_block_count/1" do
-    {:ok, count} = Blockchain.get_block_count()
-    assert 200 == count
+    {:ok, count} = NeoNode.get_block_count(@fake_node_url)
+    assert 2_400_000 == count
   end
 
   test "get_transaction/2" do
@@ -227,20 +238,23 @@ defmodule Neoscan.Blockchain.BlockchainTest do
                vouts: [],
                claims: []
              }
-           } == Blockchain.get_transaction(txid)
+           } == NeoNode.get_transaction(@fake_node_url, txid)
 
     assert {:ok, %{scripts: [%{}, %{"contract" => _}]}} =
-             Blockchain.get_transaction(
+             NeoNode.get_transaction(
+               @fake_node_url,
                "fd161ccd87deab812daa433cbc0f8f6468de24f1d708187beef5ab9ada7050f3"
              )
 
     assert {:ok, %{scripts: [%{}, %{}, %{"script" => _}]}} =
-             Blockchain.get_transaction(
+             NeoNode.get_transaction(
+               @fake_node_url,
                "45ced268026de0fcaf7035e4960e860b98fe1ae5122e716d9daac1163f13e534"
              )
 
     assert {:error, %{"code" => -100, "message" => _message}} =
-             Blockchain.get_transaction(
+             NeoNode.get_transaction(
+               @fake_node_url,
                "0000000000000000000000000000000000000000000000000000000000000000"
              )
   end
@@ -273,10 +287,11 @@ defmodule Neoscan.Blockchain.BlockchainTest do
                type: :governing_token,
                version: 0
              }
-           } == Blockchain.get_asset(txid)
+           } == NeoNode.get_asset(@fake_node_url, txid)
 
     assert {:error, %{"code" => -100, "message" => _message}} =
-             Blockchain.get_asset(
+             NeoNode.get_asset(
+               @fake_node_url,
                "0x0000000000000000000000000000000000000000000000000000000000000000"
              )
   end
@@ -303,9 +318,9 @@ defmodule Neoscan.Blockchain.BlockchainTest do
                script: <<1, 31>>,
                version: 0
              }
-           } = Blockchain.get_contract(contract_hash)
+           } = NeoNode.get_contract(@fake_node_url, contract_hash)
 
     assert {:error, %{"code" => -100, "message" => _message}} =
-             Blockchain.get_contract("0x0000000000000000000000000000000000000000")
+             NeoNode.get_contract(@fake_node_url, "0x0000000000000000000000000000000000000000")
   end
 end