[GH-#79] Checks if peers nonces are equal

Author: HristianHristov

README.md

@@ -29,31 +29,31 @@ To suspend/stop the miner from mining:
 `Aecore.Miner.Worker.suspend() `
 
 #### **API calls**
-To add block to the blockchain: 
+To add a block to the blockchain: 
 
 `Aecore.Chain.Worker.add_block(%Block{}) :: :ok`
 
-To get the all blocks in the current chain: 
+To get all blocks in the current chain: 
 
 `Aecore.Chain.Worker.all_blocks() :: list()`
 
-To get latest block added to the chain: 
+To get the latest block added to the chain: 
 
 `Aecore.Chain.Worker.latest_block() :: %Block{}`
 
 To get the latest chainstate: 
 
 `Aecore.Chain.Worker.chain_state() :: map()`
 
-To add transaction to the Transaction Pool:
+To add a transaction to the Transaction Pool:
 
 `Aecore.Txs.Pool.Worker.add_transaction(%SignedTx{}) :: :ok | :error`
 
-To remove transaction from the Transaction Pool: 
+To remove a transaction from the Transaction Pool: 
 
 `Aecore.Txs.Pool.Worker.remove_transaction(%SignedTx{}) :: :ok | :error`
 
-To inspect transactions in the Transaction Pool: 
+To inspect all transactions in the Transaction Pool: 
 
 `Aecore.Txs.Pool.Worker.get_pool() :: map() `
 
@@ -74,4 +74,4 @@ the log can be found in the source folder under:`apps/aecore/logs`
 
 ## HTTP-API
 
-The node will run a http api at `localhost:4000`
+The node will run an http API at `localhost:4000`

apps/aecore/lib/aecore.ex

@@ -2,14 +2,12 @@ defmodule Aecore do
   use Application
 
   def start(_type, _args) do
-    import Supervisor.Spec
-
     children = [
-      supervisor(Aecore.Keys.Worker.Supervisor, []),
-      supervisor(Aecore.Chain.Worker.Supervisor, []),
-      supervisor(Aecore.Miner.Worker.Supervisor, []),
-      supervisor(Aecore.Txs.Pool.Worker.Supervisor, []),
-      supervisor(Aecore.Peers.Worker.Supervisor, [])
+      Aecore.Keys.Worker.Supervisor,
+      Aecore.Chain.Worker.Supervisor,
+      Aecore.Miner.Worker.Supervisor,
+      Aecore.Txs.Pool.Worker.Supervisor,
+      Aecore.Peers.Worker.Supervisor
     ]
 
     Supervisor.start_link(children, strategy: :one_for_one)

apps/aecore/lib/aecore/chain/worker.ex

@@ -7,109 +7,137 @@ defmodule Aecore.Chain.Worker do
 
   alias Aecore.Structures.Block
   alias Aecore.Chain.ChainState
-  alias Aecore.Utils.Blockchain.BlockValidation
-  alias Aecore.Utils.Blockchain.Difficulty
   alias Aecore.Txs.Pool.Worker, as: Pool
+  alias Aecore.Utils.Blockchain.BlockValidation
+  alias Aecore.Peers.Worker, as: Peers
 
   use GenServer
 
-  def start_link do
-    GenServer.start_link(
-      __MODULE__,
-      {[Block.genesis_block()], ChainState.calculate_block_state(Block.genesis_block().txs)},
-      name: __MODULE__
-    )
+  def start_link(_args) do
+    GenServer.start_link(__MODULE__, {}, name: __MODULE__)
   end
 
-  def init(initial_state) do
+  def init(_) do
+    genesis_block_hash = BlockValidation.block_header_hash(Block.genesis_block().header)
+
+    genesis_block_map = %{genesis_block_hash => Block.genesis_block()}
+    genesis_chain_state = ChainState.calculate_block_state(Block.genesis_block().txs)
+    latest_block_chain_state = %{genesis_block_hash => genesis_chain_state}
+
+    initial_state = {genesis_block_map, latest_block_chain_state}
+
     {:ok, initial_state}
   end
 
   @spec latest_block() :: %Block{}
   def latest_block() do
-    GenServer.call(__MODULE__, :latest_block)
-  end
+    latest_block_hashes = get_latest_block_chain_state() |> Map.keys()
+    latest_block_hash = case(length(latest_block_hashes)) do
+      1 -> List.first(latest_block_hashes)
+      _ -> throw({:error, "multiple or none latest block hashes"})
+    end
 
-  @spec get_prior_blocks_for_validity_check() :: tuple()
-  def get_prior_blocks_for_validity_check() do
-    GenServer.call(__MODULE__, :get_prior_blocks_for_validity_check)
+    get_block(latest_block_hash)
   end
 
-  @spec get_block_by_hash(term()) :: %Block{}
-  def get_block_by_hash(hash) do
-    GenServer.call(__MODULE__, {:get_block_by_hash, hash})
+  @spec get_latest_block_chain_state() :: tuple()
+  def get_latest_block_chain_state() do
+    GenServer.call(__MODULE__, :get_latest_block_chain_state)
   end
 
-  @spec all_blocks() :: list()
-  def all_blocks() do
-    GenServer.call(__MODULE__, :all_blocks)
+  @spec get_block_by_hex_hash(term()) :: %Block{}
+  def get_block_by_hex_hash(hash) do
+    GenServer.call(__MODULE__, {:get_block_by_hex_hash, hash})
   end
 
-  @spec add_block(%Block{}) :: :ok
-  def add_block(%Block{} = b) do
-    GenServer.call(__MODULE__, {:add_block, b})
+  @spec get_block(term()) :: %Block{}
+  def get_block(hash) do
+    GenServer.call(__MODULE__, {:get_block, hash})
   end
 
-  @spec chain_state() :: map()
-  def chain_state() do
-    GenServer.call(__MODULE__, :chain_state)
+  @spec get_blocks(binary(), integer()) :: :ok
+  def get_blocks(start_block_hash, size) do
+    Enum.reverse(get_blocks([], start_block_hash, size))
   end
 
-  @spec get_blocks_for_difficulty_calculation() :: list()
-  def get_blocks_for_difficulty_calculation() do
-    GenServer.call(__MODULE__, :get_blocks_for_difficulty_calculation)
+  @spec add_block(%Block{}) :: :ok
+  def add_block(%Block{} = block) do
+    GenServer.call(__MODULE__, {:add_block, block})
   end
 
-  def handle_call(:latest_block, _from, state) do
-    [lb | _] = elem(state, 0)
-    {:reply, lb, state}
+  @spec chain_state(binary()) :: map()
+  def chain_state(latest_block_hash) do
+    GenServer.call(__MODULE__, {:chain_state, latest_block_hash})
   end
 
-  def handle_call(:get_prior_blocks_for_validity_check, _from, state) do
-    chain = elem(state, 0)
-
-    if length(chain) == 1 do
-      [lb | _] = chain
-      {:reply, {lb, nil}, state}
-    else
-      [lb, prev | _] = chain
-      {:reply, {lb, prev}, state}
-    end
+  def handle_call(:get_latest_block_chain_state, _from, state) do
+    {_, latest_block_chain_state} = state
+    {:reply, latest_block_chain_state, state}
   end
 
-  def handle_call({:get_block_by_hash, hash}, _from, state) do
-    block = Enum.find(elem(state, 0), fn(block) ->
-      block.header
-      |> BlockValidation.block_header_hash()
-      |> Base.encode16() == hash end)
+  def handle_call({:get_block, block_hash}, _from, state) do
+    {block_map, _} = state
+    block = block_map[block_hash]
+
     if(block != nil) do
       {:reply, block, state}
     else
       {:reply, {:error, "Block not found"}, state}
     end
   end
 
-  def handle_call(:all_blocks, _from, state) do
-    chain = elem(state, 0)
-    {:reply, chain, state}
+  def handle_call({:get_block_by_hex_hash, hash}, _from, state) do
+    {chain, _} = state
+    case(Enum.find(chain, fn{block_hash, _block} ->
+      block_hash |> Base.encode16() == hash end)) do
+      {_, block} ->
+        {:reply, block, state}
+      nil ->
+        {:reply, {:error, "Block not found"}, state}
+    end
   end
 
-  def handle_call({:add_block, %Block{} = b}, _from, state) do
-    {chain, prev_chain_state} = state
-    [prior_block | _] = chain
-    new_block_state = ChainState.calculate_block_state(b.txs)
-    new_chain_state = ChainState.calculate_chain_state(new_block_state, prev_chain_state)
+  def handle_call({:add_block, %Block{} = block}, _from, state) do
+    {chain, chain_state} = state
+    prev_block_chain_state = chain_state[block.header.prev_hash]
+    new_block_state = ChainState.calculate_block_state(block.txs)
+    new_chain_state = ChainState.calculate_chain_state(new_block_state, prev_block_chain_state)
 
     try do
-      BlockValidation.validate_block!(b, prior_block, new_chain_state)
-      Enum.each(b.txs, fn(tx) -> Pool.remove_transaction(tx) end)
+      BlockValidation.validate_block!(block, chain[block.header.prev_hash], new_chain_state)
+
+      Enum.each(block.txs, fn(tx) -> Pool.remove_transaction(tx) end)
+
+      {block_map, latest_block_chain_state} = state
+      block_hash = BlockValidation.block_header_hash(block.header)
+      updated_block_map = Map.put(block_map, block_hash, block)
+      has_prev_block = Map.has_key?(latest_block_chain_state, block.header.prev_hash)
+
+      {deleted_latest_chain_state, prev_chain_state} = case has_prev_block do
+        true ->
+          prev_chain_state = Map.get(latest_block_chain_state, block.header.prev_hash)
+          {Map.delete(latest_block_chain_state, block.header.prev_hash), prev_chain_state}
+        false ->
+          {latest_block_chain_state, %{}}
+      end
+
+      new_block_state = ChainState.calculate_block_state(block.txs)
+      new_chain_state = ChainState.calculate_chain_state(new_block_state, prev_chain_state)
+
+      updated_latest_block_chainstate = Map.put(deleted_latest_chain_state, block_hash, new_chain_state)
+
       total_tokens = ChainState.calculate_total_tokens(new_chain_state)
+
       Logger.info(fn ->
-        "Added block ##{b.header.height} with hash #{b.header
+        "Added block ##{block.header.height} with hash #{block.header
         |> BlockValidation.block_header_hash()
         |> Base.encode16()}, total tokens: #{total_tokens}"
       end)
-      {:reply, :ok, {[b | chain], new_chain_state}}
+
+      ## Block was validated, now we can send it to other peers
+      Peers.broadcast_to_all({:new_block, block})
+
+      {:reply, :ok, {updated_block_map, updated_latest_block_chainstate}}
     catch
       {:error, message} ->
         Logger.error(fn ->
@@ -119,15 +147,37 @@ defmodule Aecore.Chain.Worker do
     end
   end
 
-  def handle_call(:chain_state, _from, state) do
-    chain_state = elem(state, 1)
-    {:reply, chain_state, state}
+  def handle_call({:chain_state, latest_block_hash}, _from, state) do
+    {_, chain_state} = state
+    {:reply, chain_state[latest_block_hash], state}
   end
 
-  def handle_call(:get_blocks_for_difficulty_calculation, _from, state) do
-    chain = elem(state, 0)
-    number_of_blocks = Difficulty.get_number_of_blocks()
-    blocks_for_difficulty_calculation = Enum.take(chain, number_of_blocks)
-    {:reply, blocks_for_difficulty_calculation, state}
+  def chain_state() do
+    latest_block = latest_block()
+    latest_block_hash = BlockValidation.block_header_hash(latest_block.header)
+    chain_state(latest_block_hash)
+  end
+
+  def all_blocks() do
+    latest_block_obj = latest_block()
+    latest_block_hash = BlockValidation.block_header_hash(latest_block_obj.header)
+    get_blocks(latest_block_hash, latest_block_obj.header.height)
+  end
+
+  defp get_blocks(blocks_acc, next_block_hash, size) do
+    cond do
+      size > 0 ->
+        case(GenServer.call(__MODULE__, {:get_block, next_block_hash})) do
+          {:error, _} -> blocks_acc
+          block ->
+            updated_block_acc = [block | blocks_acc]
+            prev_block_hash = block.header.prev_hash
+            next_size = size - 1
+
+            get_blocks(updated_block_acc, prev_block_hash, next_size)
+        end
+      true ->
+        blocks_acc
+    end
   end
 end

apps/aecore/lib/aecore/chain/worker/supervisor.ex

@@ -1,15 +1,15 @@
 defmodule Aecore.Chain.Worker.Supervisor do
   use Supervisor
 
-  def start_link() do
+  def start_link(_args) do
     Supervisor.start_link(__MODULE__, :ok)
   end
 
   def init(:ok) do
     children = [
-      worker(Aecore.Chain.Worker, [])
+     Aecore.Chain.Worker
     ]
 
-    supervise(children, strategy: :one_for_one)
+    Supervisor.init(children, strategy: :one_for_one)
   end
 end

apps/aecore/lib/aecore/keys/worker.ex

@@ -9,8 +9,9 @@ defmodule Aecore.Keys.Worker do
 
   @filename_pub "key.pub"
   @filename_priv "key"
+  @pub_key_length 65
 
-  def start_link() do
+  def start_link(_args) do
     GenServer.start_link(
       __MODULE__,
       %{
@@ -123,19 +124,23 @@ defmodule Aecore.Keys.Worker do
       0
     }
   end
-
   def handle_call(
         {:verify, {term, signature, pub_key}},
         _from,
         %{algo: algo, digest: digest, curve: curve} = state
       ) do
-    result =
-      :crypto.verify(algo, digest, :erlang.term_to_binary(term), signature, [
-        pub_key,
-        :crypto.ec_curve(curve)
-      ])
+    case is_valid_pub_key(pub_key) do
+      true ->
+        result =
+          :crypto.verify(algo, digest, :erlang.term_to_binary(term), signature, [
+                pub_key,
+                :crypto.ec_curve(curve)
+              ])
 
-    {:reply, result, state}
+        {:reply, result, state}
+      false ->
+        {:reply, {:error, "Key length is not valid!"}, state}
+    end
   end
 
   def handle_call(
@@ -294,6 +299,11 @@ defmodule Aecore.Keys.Worker do
     pub
   end
 
+  defp is_valid_pub_key(pub_key_str) do
+    pub_key_str
+    |> byte_size() == @pub_key_length
+  end
+
   defp padding128(bin) do
     pad0 = 128 - :erlang.size(bin)
     pad1 = pad0 * 8

apps/aecore/lib/aecore/keys/worker/supervisor.ex

@@ -1,15 +1,15 @@
 defmodule Aecore.Keys.Worker.Supervisor do
   use Supervisor
 
-  def start_link() do
+  def start_link(_args) do
     Supervisor.start_link(__MODULE__, :ok)
   end
 
   def init(:ok) do
     children = [
-      worker(Aecore.Keys.Worker, [])
+      Aecore.Keys.Worker
     ]
 
-    supervise(children, strategy: :one_for_one)
+    Supervisor.init(children, strategy: :one_for_one)
   end
 end