Fix the logic to distribute transaction fee

The stakeholders share the minimum fee and the author has the
remainders.

Author: Seulgi Kim

core/src/consensus/tendermint/engine.rs

@@ -23,6 +23,7 @@ use cnetwork::NetworkService;
 use crossbeam_channel as crossbeam;
 use cstate::ActionHandler;
 use ctypes::machine::WithBalances;
+use ctypes::transaction::Action;
 use ctypes::BlockNumber;
 use primitives::H256;
 use rlp::UntrustedRlp;
@@ -195,13 +196,21 @@ impl ConsensusEngine<CodeChainMachine> for Tendermint {
 
     fn on_close_block(&self, block: &mut ExecutedBlock) -> Result<(), Error> {
         let author = *block.header().author();
-        let transactions = block.transactions().to_owned().into_iter();
-        let fee = transactions.map(|tx| tx.fee).sum();
+        let (total_fee, min_fee) = {
+            let transactions = block.transactions();
+            let total_fee: u64 = transactions.iter().map(|tx| tx.fee).sum();
+            let min_fee = transactions.iter().map(|tx| self.minimum_fee(&tx.action)).sum();
+            (total_fee, min_fee)
+        };
+        assert!(total_fee >= min_fee, "{} >= {}", total_fee, min_fee);
         let stakes = stake::get_stakes(block.state()).expect("Cannot get Stake status");
 
-        for (address, share) in stake::fee_distribute(&author, fee, &stakes) {
+        for (address, share) in stake::fee_distribute(&author, min_fee, &stakes) {
             self.machine.add_balance(block, &address, share)?
         }
+        if total_fee != min_fee {
+            self.machine.add_balance(block, &author, total_fee - min_fee)?
+        }
         Ok(())
     }
 
@@ -287,6 +296,62 @@ impl ConsensusEngine<CodeChainMachine> for Tendermint {
     }
 }
 
+impl Tendermint {
+    fn minimum_fee(&self, action: &Action) -> u64 {
+        let params = self.machine.params();
+        match action {
+            Action::MintAsset {
+                ..
+            } => params.min_asset_mint_cost,
+            Action::TransferAsset {
+                ..
+            } => params.min_asset_transfer_cost,
+            Action::ChangeAssetScheme {
+                ..
+            } => params.min_asset_scheme_change_cost,
+            Action::IncreaseAssetSupply {
+                ..
+            } => params.min_asset_supply_increase_cost,
+            Action::ComposeAsset {
+                ..
+            } => params.min_asset_compose_cost,
+            Action::DecomposeAsset {
+                ..
+            } => params.min_asset_decompose_cost,
+            Action::UnwrapCCC {
+                ..
+            } => params.min_asset_unwrap_ccc_cost,
+            Action::Pay {
+                ..
+            } => params.min_pay_transaction_cost,
+            Action::SetRegularKey {
+                ..
+            } => params.min_set_regular_key_tranasction_cost,
+            Action::CreateShard {
+                ..
+            } => params.min_create_shard_transaction_cost,
+            Action::SetShardOwners {
+                ..
+            } => params.min_set_shard_owners_transaction_cost,
+            Action::SetShardUsers {
+                ..
+            } => params.min_set_shard_users_transaction_cost,
+            Action::WrapCCC {
+                ..
+            } => params.min_wrap_ccc_transaction_cost,
+            Action::Custom {
+                ..
+            } => params.min_custom_transaction_cost,
+            Action::Store {
+                ..
+            } => params.min_store_transaction_cost,
+            Action::Remove {
+                ..
+            } => params.min_remove_transaction_cost,
+        }
+    }
+}
+
 fn combine_proofs(signal_number: BlockNumber, set_proof: &[u8], finality_proof: &[u8]) -> Vec<u8> {
     let mut stream = ::rlp::RlpStream::new_list(3);
     stream.append(&signal_number).append(&set_proof).append(&finality_proof);