[GH-#83] Added fee to transactions

Author: cheezus1

apps/aecore/lib/aecore/chain/chain_state.ex

@@ -4,6 +4,8 @@ defmodule Aecore.Chain.ChainState do
   The chain state is a map, telling us what amount of tokens each account has.
   """
 
+  alias Aecore.Keys.Worker, as: Keys
+
   @doc """
   Calculates the balance of each account mentioned
   in the transactions a single block, returns a map with the
@@ -19,7 +21,8 @@ defmodule Aecore.Chain.ChainState do
           cond do
             transaction.data.from_acc != nil ->
               update_block_state(block_state, transaction.data.from_acc,
-                                 -transaction.data.value, transaction.data.nonce)
+                                 -(transaction.data.value + transaction.data.fee),
+                                 transaction.data.nonce)
 
             true ->
               block_state
@@ -79,6 +82,25 @@ defmodule Aecore.Chain.ChainState do
       Enum.all?()
   end
 
+  @spec add_fees_to_block_state(list(), map()) :: map()
+  def add_fees_to_block_state(txs, block_state) do
+    pubkey = elem(Keys.pubkey(), 1)
+    total_fees = List.foldl(txs, 0, fn(tx, acc) ->
+        acc + tx.data.fee
+      end)
+
+    cond do
+      !Map.has_key?(block_state, pubkey) ->
+        Map.put(block_state, pubkey, %{balance: total_fees, nonce: 0})
+
+      true ->
+        current_pubkey_block_state = Map.get(block_state, pubkey)
+        new_pubkey_block_state = %{balance: current_pubkey_block_state.balance + total_fees,
+                                   nonce: current_pubkey_block_state.nonce}
+        Map.replace(block_state, pubkey, new_pubkey_block_state)
+    end
+  end
+
   @spec update_block_state(map(), binary(), integer(), integer()) :: map()
   defp update_block_state(block_state, account, value, nonce) do
     block_state_filled_empty =

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

@@ -98,7 +98,8 @@ defmodule Aecore.Chain.Worker 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)
+    new_block_state_with_fees = ChainState.add_fees_to_block_state(b.txs, new_block_state)
+    new_chain_state = ChainState.calculate_chain_state(new_block_state_with_fees, prev_chain_state)
 
     try do
       BlockValidation.validate_block!(b, prior_block, new_chain_state)

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

@@ -38,10 +38,10 @@ defmodule Aecore.Keys.Worker do
      - value: The amount of a transaction
 
   """
-  @spec sign_tx(binary(), integer(), integer()) :: {:ok, %SignedTx{}}
-  def sign_tx(to_acc, value, nonce) do
+  @spec sign_tx(binary(), integer(), integer(), integer()) :: {:ok, %SignedTx{}}
+  def sign_tx(to_acc, value, nonce, fee) do
     {:ok, from_acc} = pubkey()
-    {:ok, tx_data} = TxData.create(from_acc, to_acc, value, nonce)
+    {:ok, tx_data} = TxData.create(from_acc, to_acc, value, nonce, fee)
     {:ok, signature} = sign(tx_data)
     signed_tx = %SignedTx{data: tx_data, signature: signature}
     {:ok, signed_tx}

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

@@ -95,7 +95,8 @@ defmodule Aecore.Miner.Worker do
       from_acc: nil,
       to_acc: to_acc,
       value: @coinbase_transaction_value,
-      nonce: 0
+      nonce: 0,
+      fee: 0
     }
 
     %SignedTx{data: tx_data, signature: nil}
@@ -122,7 +123,9 @@ defmodule Aecore.Miner.Worker do
     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)
+    new_block_state_with_fees = ChainState.add_fees_to_block_state(valid_txs, new_block_state)
+
+    new_chain_state = ChainState.calculate_chain_state(new_block_state_with_fees, chain_state)
     chain_state_hash = ChainState.calculate_chain_state_hash(new_chain_state)
 
     latest_block_hash = BlockValidation.block_header_hash(latest_block.header)

apps/aecore/lib/aecore/structures/tx_data.ex

@@ -15,11 +15,11 @@ defmodule Aecore.Structures.TxData do
      - to_acc: To account is the public address of the account receiving the transaction
      - value: The amount of a transaction
   """
-  defstruct [:nonce, :from_acc, :to_acc, :value]
+  defstruct [:nonce, :from_acc, :to_acc, :value, :fee]
   use ExConstructor
 
-  @spec create(binary(), binary(), integer(), integer()) :: {:ok, %TxData{}}
-  def create(from_acc, to_acc, value, nonce) do
-    {:ok, %TxData{from_acc: from_acc, to_acc: to_acc, value: value, nonce: nonce}}
+  @spec create(binary(), binary(), integer(), integer(), integer()) :: {:ok, %TxData{}}
+  def create(from_acc, to_acc, value, nonce, fee) do
+    {:ok, %TxData{from_acc: from_acc, to_acc: to_acc, value: value, nonce: nonce, fee: fee}}
   end
 end

apps/aecore/test/aecore_chain_state_test.exs

@@ -14,9 +14,9 @@ defmodule AecoreChainStateTest do
   test "block state" do
     block = get_block()
 
-    assert %{"a" => %{balance:  3, nonce: 102},
-             "b" => %{balance: -1, nonce: 1},
-             "c" => %{balance: -2, nonce: 1}} ==
+    assert %{"a" => %{balance:  1, nonce: 102},
+             "b" => %{balance: -2, nonce: 1},
+             "c" => %{balance: -3, nonce: 1}} ==
       ChainState.calculate_block_state(block.txs)
   end
 
@@ -38,13 +38,13 @@ defmodule AecoreChainStateTest do
            txs_hash: <<12, 123, 12>>, difficulty_target: 0, nonce: 0,
            timestamp: System.system_time(:milliseconds), version: 1}, txs: [
              %SignedTx{data: %TxData{from_acc: "a", to_acc: "b",
-              value: 5, nonce: 101}, signature: <<0>>},
+              value: 5, nonce: 101, fee: 1}, signature: <<0>>},
              %SignedTx{data: %TxData{from_acc: "a", to_acc: "c",
-              value: 2, nonce: 102}, signature: <<0>>},
+              value: 2, nonce: 102, fee: 1}, signature: <<0>>},
              %SignedTx{data: %TxData{from_acc: "c", to_acc: "b",
-              value: 4, nonce: 1}, signature: <<0>>},
+              value: 4, nonce: 1, fee: 1}, signature: <<0>>},
              %SignedTx{data: %TxData{from_acc: "b", to_acc: "a",
-              value: 10, nonce: 1}, signature: <<0>>}]}
+              value: 10, nonce: 1, fee: 1}, signature: <<0>>}]}
   end
 
 end

apps/aecore/test/aecore_keys_test.exs

@@ -20,6 +20,6 @@ defmodule AecoreKeysTest do
 
   test "sign transaction" do
     {:ok, to_account} = Keys.pubkey()
-    assert {:ok, _} = Keys.sign_tx(to_account, 5, Map.get(Chain.chain_state, to_account, %{nonce: 0}).nonce + 1)
+    assert {:ok, _} = Keys.sign_tx(to_account, 5, Map.get(Chain.chain_state, to_account, %{nonce: 0}).nonce + 1, 1)
   end
 end

apps/aecore/test/aecore_tx_test.exs

@@ -15,7 +15,7 @@ defmodule AecoreTxTest do
 
   test "create and verify a signed tx" do
     {:ok, to_account} = Keys.pubkey()
-    {:ok, tx} = Keys.sign_tx(to_account, 5, Map.get(Chain.chain_state, to_account, %{nonce: 0}).nonce + 1)
+    {:ok, tx} = Keys.sign_tx(to_account, 5, Map.get(Chain.chain_state, to_account, %{nonce: 0}).nonce + 1, 1)
 
     assert :true = Keys.verify_tx(tx)
   end

apps/aecore/test/aecore_txs_pool_test.exs

@@ -18,9 +18,9 @@ defmodule AecoreTxsPoolTest do
   test "add transaction, remove it and get pool" do
     {:ok, to_account} = Keys.pubkey()
     {:ok, tx1} = Keys.sign_tx(to_account, 5,
-                              Map.get(Chain.chain_state, to_account, %{nonce: 0}).nonce + 1)
+                              Map.get(Chain.chain_state, to_account, %{nonce: 0}).nonce + 1, 1)
     {:ok, tx2} = Keys.sign_tx(to_account, 5,
-                              Map.get(Chain.chain_state, to_account, %{nonce: 0}).nonce + 1)
+                              Map.get(Chain.chain_state, to_account, %{nonce: 0}).nonce + 1, 1)
     Miner.resume()
     Miner.suspend()
     assert :ok = Pool.add_transaction(tx1)

apps/aecore/test/aecore_validation_test.exs

@@ -55,9 +55,9 @@ defmodule AecoreValidationTest do
   test "validate transactions in a block" do
     {:ok, to_account} = Keys.pubkey()
     {:ok, tx1} = Keys.sign_tx(to_account, 5,
-                              Map.get(Chain.chain_state, to_account, %{nonce: 0}).nonce + 1)
+                              Map.get(Chain.chain_state, to_account, %{nonce: 0}).nonce + 1, 1)
     {:ok, tx2} = Keys.sign_tx(to_account, 10,
-                              Map.get(Chain.chain_state, to_account, %{nonce: 0}).nonce + 1)
+                              Map.get(Chain.chain_state, to_account, %{nonce: 0}).nonce + 1, 1)
 
     block = %{Block.genesis_block | txs: [tx1, tx2]}
     assert block |> BlockValidation.validate_block_transactions