Added exception handling for miner and add_block and small refactoring

Author: nedelcho-delchev-tues

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

@@ -73,18 +73,6 @@ defmodule Aecore.Chain.Worker do
     {:reply, latest_block_chain_state, state}
   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
-  end
-
   def handle_call({:get_block, block_hash}, _from, state) do
     {block_map, _} = state
     block = block_map[block_hash]
@@ -97,7 +85,8 @@ defmodule Aecore.Chain.Worker do
   end
 
   def handle_call({:get_block_by_hex_hash, hash}, _from, state) do
-    case(Enum.find(elem(state, 0), fn{block_hash, _block} ->
+    {chain, _} = state
+    case(Enum.find(chain, fn{block_hash, _block} ->
       block_hash |> Base.encode16() == hash end)) do
       {_, block} ->
         {:reply, block, state}
@@ -112,41 +101,49 @@ defmodule Aecore.Chain.Worker do
     new_block_state = ChainState.calculate_block_state(block.txs)
     new_chain_state = ChainState.calculate_chain_state(new_block_state, prev_block_chain_state)
 
-    BlockValidation.validate_block!(block, chain[block.header.prev_hash], new_chain_state)
+    try do
+      BlockValidation.validate_block!(block, chain[block.header.prev_hash], new_chain_state)
 
-    Enum.each(block.txs, fn(tx) -> Pool.remove_transaction(tx) end)
+      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)
+      {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)
+      {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
 
-    updated_latest_block_chainstate = Map.put(deleted_latest_chain_state, block_hash, new_chain_state)
+      new_block_state = ChainState.calculate_block_state(block.txs)
+      new_chain_state = ChainState.calculate_chain_state(new_block_state, prev_chain_state)
 
-    total_tokens = ChainState.calculate_total_tokens(new_chain_state)
+      updated_latest_block_chainstate = Map.put(deleted_latest_chain_state, block_hash, new_chain_state)
 
-    Logger.info(
-      fn ->
-        "Added block ##{block.header.height} with hash #{
-          block.header
-          |> BlockValidation.block_header_hash()
-          |> Base.encode16()
-        }, total tokens: #{total_tokens}"
-      end
-    )
+      total_tokens = ChainState.calculate_total_tokens(new_chain_state)
 
-    {:reply, :ok, {updated_block_map, updated_latest_block_chainstate}}
+      Logger.info(
+        fn ->
+          "Added block ##{block.header.height} with hash #{
+            block.header
+            |> BlockValidation.block_header_hash()
+            |> Base.encode16()
+          }, total tokens: #{total_tokens}"
+        end
+      )
+
+      {:reply, :ok, {updated_block_map, updated_latest_block_chainstate}}
+    catch
+      {:error, message} ->
+        Logger.error(fn ->
+          "Failed to add block: #{message}"
+        end)
+      {:reply, :error, state}
+    end
   end
 
   def handle_call({:chain_state, latest_block_hash}, _from, state) do

apps/aecore/lib/aecore/miner/worker.ex

@@ -41,7 +41,7 @@ defmodule Aecore.Miner.Worker do
 
   ## Idle ##
   def idle({:call, from}, :start, _data) do
-    IO.puts("Mining resuming by user")
+    IO.puts("Mining resumed by user")
     GenStateMachine.cast(__MODULE__, :mine)
     {:next_state, :running, 0, [{:reply, from, :ok}]}
   end
@@ -78,7 +78,7 @@ defmodule Aecore.Miner.Worker do
   end
 
   def running({:call, from}, :suspend, data) do
-    IO.puts("Mined stop by user")
+    IO.puts("Mining stopped by user")
     {:next_state, :idle, data, [{:reply, from, :ok}]}
   end
 
@@ -120,45 +120,51 @@ defmodule Aecore.Miner.Worker do
         blocks = Chain.get_blocks(latest_block_hash, 2)
         Enum.at(blocks, 1)
     end
-
-    BlockValidation.validate_block!(latest_block, previous_block, chain_state)
-
-    valid_txs = BlockValidation.filter_invalid_transactions_chainstate(ordered_txs_list, chain_state)
-    {_, pubkey} = Keys.pubkey()
-    valid_txs = [get_coinbase_transaction(pubkey) | valid_txs]
-    root_hash = BlockValidation.calculate_root_hash(valid_txs)
-
-    new_block_state = ChainState.calculate_block_state(valid_txs)
-    new_chain_state = ChainState.calculate_chain_state(new_block_state, chain_state)
-    chain_state_hash = ChainState.calculate_chain_state_hash(new_chain_state)
-
-    latest_block_hash = BlockValidation.block_header_hash(latest_block.header)
-
-    difficulty = Difficulty.calculate_next_difficulty(blocks_for_difficulty_calculation)
-
-    unmined_header =
-      Header.create(
-        latest_block.header.height + 1,
-        latest_block_hash,
-        root_hash,
-        chain_state_hash,
-        difficulty,
-        0, #start from nonce 0, will be incremented in mining
-        Block.current_block_version()
-      )
-    Logger.debug("start nonce #{start_nonce}. Final nonce = #{start_nonce + @nonce_per_cycle}")
-    case Cuckoo.generate(%{unmined_header
-                           | nonce: start_nonce + @nonce_per_cycle}) do
-      {:ok, mined_header} ->
-        block = %Block{header: mined_header, txs: valid_txs}
-        Chain.add_block(block)
-        Logger.info(fn ->
-          "Mined block ##{block.header.height}, difficulty target #{block.header.difficulty_target}, nonce #{block.header.nonce}"
-          end)
-        {:block_found, 0}
-
+    try do
+      BlockValidation.validate_block!(latest_block, previous_block, chain_state)
+
+      valid_txs = BlockValidation.filter_invalid_transactions_chainstate(ordered_txs_list, chain_state)
+      {_, pubkey} = Keys.pubkey()
+      valid_txs = [get_coinbase_transaction(pubkey) | valid_txs]
+      root_hash = BlockValidation.calculate_root_hash(valid_txs)
+
+      new_block_state = ChainState.calculate_block_state(valid_txs)
+      new_chain_state = ChainState.calculate_chain_state(new_block_state, chain_state)
+      chain_state_hash = ChainState.calculate_chain_state_hash(new_chain_state)
+
+      latest_block_hash = BlockValidation.block_header_hash(latest_block.header)
+
+      difficulty = Difficulty.calculate_next_difficulty(blocks_for_difficulty_calculation)
+
+      unmined_header =
+        Header.create(
+          latest_block.header.height + 1,
+          latest_block_hash,
+          root_hash,
+          chain_state_hash,
+          difficulty,
+          0, #start from nonce 0, will be incremented in mining
+          Block.current_block_version()
+        )
+      Logger.debug("start nonce #{start_nonce}. Final nonce = #{start_nonce + @nonce_per_cycle}")
+      case Cuckoo.generate(%{unmined_header
+                             | nonce: start_nonce + @nonce_per_cycle}) do
+        {:ok, mined_header} ->
+          block = %Block{header: mined_header, txs: valid_txs}
+          Logger.info(fn ->
+            "Mined block ##{block.header.height}, difficulty target #{block.header.difficulty_target}, nonce #{block.header.nonce}"
+            end)
+          Chain.add_block(block)
+          {:block_found, 0}
+
+        {:error, _message} ->
+          {:no_block_found, start_nonce + @nonce_per_cycle}
+      end
+    catch
       {:error, _message} ->
-        {:no_block_found, start_nonce + @nonce_per_cycle}
+        Logger.error(fn ->
+          "Failed to mine block"
+        end)
     end
   end
 end