Add an RPC getting minimum fees confiugred by each machine

core/src/client/client.rs

@@ -31,6 +31,7 @@ use crate::scheme::Scheme;
 use crate::service::ClientIoMessage;
 use crate::transaction::{LocalizedTransaction, PendingSignedTransactions, SignedTransaction, UnverifiedTransaction};
 use crate::types::{BlockId, BlockStatus, TransactionId, VerificationQueueInfo as BlockQueueInfo};
+use crate::MemPoolMinFees;
 use cdb::{new_journaldb, Algorithm, AsHashDB, DatabaseError};
 use cio::IoChannel;
 use ckey::{Address, NetworkId, PlatformAddress, Public};
@@ -826,6 +827,10 @@ impl MiningBlockChainClient for Client {
     fn register_immune_users(&self, immune_user_vec: Vec<Address>) {
         self.importer.miner.register_immune_users(immune_user_vec)
     }
+
+    fn mem_pool_min_fees(&self) -> MemPoolMinFees {
+        self.importer.miner.get_options().mem_pool_min_fees
+    }
 }
 
 impl ChainTimeInfo for Client {

core/src/client/mod.rs

@@ -33,6 +33,7 @@ use crate::blockchain_info::BlockChainInfo;
 use crate::consensus::EngineError;
 use crate::encoded;
 use crate::error::{BlockImportError, Error as GenericError};
+use crate::miner::MemPoolMinFees;
 use crate::transaction::{LocalizedTransaction, PendingSignedTransactions, SignedTransaction};
 use crate::types::{BlockId, BlockStatus, TransactionId, VerificationQueueInfo as BlockQueueInfo};
 use cdb::DatabaseError;
@@ -290,6 +291,8 @@ pub trait MiningBlockChainClient: BlockChainClient + BlockProducer + FindActionH
 
     /// Append designated users to the immune user list.
     fn register_immune_users(&self, immune_user_vec: Vec<Address>);
+
+    fn mem_pool_min_fees(&self) -> MemPoolMinFees;
 }
 
 /// Provides methods to access database.

core/src/client/test_client.rs

@@ -41,7 +41,7 @@ use crate::consensus::EngineError;
 use crate::db::{COL_STATE, NUM_COLUMNS};
 use crate::encoded;
 use crate::error::{BlockImportError, Error as GenericError};
-use crate::miner::{Miner, MinerService, TransactionImportResult};
+use crate::miner::{MemPoolMinFees, Miner, MinerService, TransactionImportResult};
 use crate::scheme::Scheme;
 use crate::transaction::{LocalizedTransaction, PendingSignedTransactions, SignedTransaction};
 use crate::types::{BlockId, TransactionId, VerificationQueueInfo as QueueInfo};
@@ -373,6 +373,10 @@ impl MiningBlockChainClient for TestBlockChainClient {
     fn register_immune_users(&self, immune_user_vec: Vec<Address>) {
         self.miner.register_immune_users(immune_user_vec)
     }
+
+    fn mem_pool_min_fees(&self) -> MemPoolMinFees {
+        self.miner.get_options().mem_pool_min_fees
+    }
 }
 
 impl AccountData for TestBlockChainClient {

core/src/lib.rs

@@ -75,7 +75,7 @@ pub use crate::consensus::stake;
 pub use crate::consensus::{EngineType, TimeGapParams};
 pub use crate::db::{COL_STATE, NUM_COLUMNS};
 pub use crate::error::{BlockImportError, Error, ImportError};
-pub use crate::miner::{MemPoolFees, Miner, MinerOptions, MinerService};
+pub use crate::miner::{MemPoolMinFees, Miner, MinerOptions, MinerService};
 pub use crate::peer_db::PeerDb;
 pub use crate::rlp::Encodable;
 pub use crate::scheme::Scheme;

core/src/miner/mem_pool.rs

@@ -16,8 +16,8 @@
 
 use super::backup;
 use super::mem_pool_types::{
-    AccountDetails, CurrentQueue, FutureQueue, MemPoolFees, MemPoolInput, MemPoolItem, MemPoolStatus, PoolingInstant,
-    QueueTag, TransactionOrder, TransactionOrderWithTag, TxOrigin, TxTimelock,
+    AccountDetails, CurrentQueue, FutureQueue, MemPoolInput, MemPoolItem, MemPoolMinFees, MemPoolStatus,
+    PoolingInstant, QueueTag, TransactionOrder, TransactionOrderWithTag, TxOrigin, TxTimelock,
 };
 use super::TransactionImportResult;
 use crate::client::{AccountData, BlockChainTrait};
@@ -73,7 +73,7 @@ impl From<SyntaxError> for Error {
 
 pub struct MemPool {
     /// Fee threshold for transactions that can be imported to this pool
-    minimum_fees: MemPoolFees,
+    minimum_fees: MemPoolMinFees,
     /// A value which is used to check whether a new transaciton can replace a transaction in the memory pool with the same signer and seq.
     /// If the fee of the new transaction is `new_fee` and the fee of the transaction in the memory pool is `old_fee`,
     /// then `new_fee > old_fee + old_fee >> mem_pool_fee_bump_shift` should be satisfied to replace.
@@ -118,7 +118,7 @@ impl MemPool {
         memory_limit: usize,
         fee_bump_shift: usize,
         db: Arc<dyn KeyValueDB>,
-        minimum_fees: MemPoolFees,
+        minimum_fees: MemPoolMinFees,
     ) -> Self {
         MemPool {
             minimum_fees,
@@ -1410,7 +1410,7 @@ pub mod test {
         let test_client = TestBlockChainClient::new();
 
         // Set the pay transaction minimum fee
-        let fees = MemPoolFees::create_from_options(
+        let fees = MemPoolMinFees::create_from_options(
             Some(150),
             None,
             None,
@@ -1463,7 +1463,7 @@ pub mod test {
     fn external_transactions_whose_fees_are_under_the_mem_pool_min_fee_are_rejected() {
         let test_client = TestBlockChainClient::new();
         // Set the pay transaction minimum fee
-        let fees = MemPoolFees::create_from_options(
+        let fees = MemPoolMinFees::create_from_options(
             Some(150),
             None,
             None,

core/src/miner/mem_pool_types.rs

@@ -420,22 +420,22 @@ pub struct AccountDetails {
 
 #[derive(Default, Clone, Copy, Debug, PartialEq)]
 /// Minimum fee thresholds defined not by network but by Mempool
-pub struct MemPoolFees {
-    min_pay_transaction_cost: u64,
-    min_set_regular_key_transaction_cost: u64,
-    min_create_shard_transaction_cost: u64,
-    min_set_shard_owners_transaction_cost: u64,
-    min_set_shard_users_transaction_cost: u64,
-    min_wrap_ccc_transaction_cost: u64,
-    min_custom_transaction_cost: u64,
-    min_asset_mint_cost: u64,
-    min_asset_transfer_cost: u64,
-    min_asset_scheme_change_cost: u64,
-    min_asset_supply_increase_cost: u64,
-    min_asset_unwrap_ccc_cost: u64,
+pub struct MemPoolMinFees {
+    pub min_pay_transaction_cost: u64,
+    pub min_set_regular_key_transaction_cost: u64,
+    pub min_create_shard_transaction_cost: u64,
+    pub min_set_shard_owners_transaction_cost: u64,
+    pub min_set_shard_users_transaction_cost: u64,
+    pub min_wrap_ccc_transaction_cost: u64,
+    pub min_custom_transaction_cost: u64,
+    pub min_asset_mint_cost: u64,
+    pub min_asset_transfer_cost: u64,
+    pub min_asset_scheme_change_cost: u64,
+    pub min_asset_supply_increase_cost: u64,
+    pub min_asset_unwrap_ccc_cost: u64,
 }
 
-impl MemPoolFees {
+impl MemPoolMinFees {
     #[allow(clippy::too_many_arguments)]
     pub fn create_from_options(
         min_pay_cost_option: Option<u64>,
@@ -451,7 +451,7 @@ impl MemPoolFees {
         min_asset_supply_increase_cost_option: Option<u64>,
         min_asset_unwrap_ccc_cost_option: Option<u64>,
     ) -> Self {
-        MemPoolFees {
+        MemPoolMinFees {
             min_pay_transaction_cost: min_pay_cost_option.unwrap_or_default(),
             min_set_regular_key_transaction_cost: min_set_regular_key_cost_option.unwrap_or_default(),
             min_create_shard_transaction_cost: min_create_shard_cost_option.unwrap_or_default(),

core/src/miner/miner.rs

@@ -15,7 +15,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use super::mem_pool::{Error as MemPoolError, MemPool};
-pub use super::mem_pool_types::MemPoolFees;
+pub use super::mem_pool_types::MemPoolMinFees;
 use super::mem_pool_types::{MemPoolInput, TxOrigin, TxTimelock};
 use super::{fetch_account_creator, MinerService, MinerStatus, TransactionImportResult};
 use crate::account_provider::{AccountProvider, Error as AccountProviderError};
@@ -69,7 +69,7 @@ pub struct MinerOptions {
     pub mem_pool_fee_bump_shift: usize,
     pub allow_create_shard: bool,
     /// Minimum fees configured by the machine.
-    pub mem_pool_fees: MemPoolFees,
+    pub mem_pool_min_fees: MemPoolMinFees,
 }
 
 impl Default for MinerOptions {
@@ -83,7 +83,7 @@ impl Default for MinerOptions {
             mem_pool_memory_limit: Some(2 * 1024 * 1024),
             mem_pool_fee_bump_shift: 3,
             allow_create_shard: false,
-            mem_pool_fees: Default::default(),
+            mem_pool_min_fees: Default::default(),
         }
     }
 }
@@ -137,7 +137,7 @@ impl Miner {
             mem_limit,
             options.mem_pool_fee_bump_shift,
             db,
-            options.mem_pool_fees,
+            options.mem_pool_min_fees,
         )));
 
         Self {

core/src/miner/mod.rs

@@ -29,7 +29,7 @@ use primitives::Bytes;
 use std::ops::Range;
 
 use self::mem_pool_types::AccountDetails;
-pub use self::mem_pool_types::MemPoolFees;
+pub use self::mem_pool_types::MemPoolMinFees;
 pub use self::miner::{AuthoringParams, Miner, MinerOptions};
 use crate::account_provider::{AccountProvider, Error as AccountProviderError};
 use crate::client::{

foundry/config/mod.rs

@@ -1,4 +1,4 @@
-// Copyright 2018-2019 Kodebox, Inc.
+// Copyright 2018-2020 Kodebox, Inc.
 // This file is part of CodeChain.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -16,7 +16,7 @@
 
 mod chain_type;
 
-use ccore::{MemPoolFees, MinerOptions, TimeGapParams};
+use ccore::{MemPoolMinFees, MinerOptions, TimeGapParams};
 use cidr::IpCidr;
 use ckey::PlatformAddress;
 use clap;
@@ -73,7 +73,7 @@ impl Config {
                 None => unreachable!(),
             };
 
-        let mem_pool_fees = MemPoolFees::create_from_options(
+        let mem_pool_min_fees = MemPoolMinFees::create_from_options(
             self.mining.min_pay_transaction_cost,
             self.mining.min_set_regular_key_transaction_cost,
             self.mining.min_create_shard_transaction_cost,
@@ -100,7 +100,7 @@ impl Config {
             reseal_on_external_transaction,
             reseal_min_period: Duration::from_millis(self.mining.reseal_min_period.unwrap()),
             no_reseal_timer: self.mining.no_reseal_timer.unwrap(),
-            mem_pool_fees,
+            mem_pool_min_fees,
         })
     }
 

rpc/src/v1/impls/mempool.rs

@@ -16,7 +16,7 @@
 
 use super::super::errors;
 use super::super::traits::Mempool;
-use super::super::types::PendingTransactions;
+use super::super::types::{MemPoolMinFees, PendingTransactions};
 use ccore::{BlockChainClient, EngineInfo, MiningBlockChainClient, SignedTransaction};
 use cjson::bytes::Bytes;
 use ckey::{Address, PlatformAddress};
@@ -114,4 +114,8 @@ where
         self.client.register_immune_users(immune_user_vec);
         Ok(())
     }
+
+    fn get_machine_minimum_fees(&self) -> Result<MemPoolMinFees> {
+        Ok(MemPoolMinFees::from(self.client.mem_pool_min_fees()))
+    }
 }

rpc/src/v1/traits/mempool.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-use super::super::types::PendingTransactions;
+use super::super::types::{MemPoolMinFees, PendingTransactions};
 use cjson::bytes::Bytes;
 use ckey::PlatformAddress;
 use ctypes::{Tracker, TxHash};
@@ -60,4 +60,7 @@ pub trait Mempool {
 
     #[rpc(name = "mempool_registerImmuneAccounts")]
     fn register_immune_accounts(&self, immune_user_list: Vec<PlatformAddress>) -> Result<()>;
+
+    #[rpc(name = "mempool_getMachineMinimumFees")]
+    fn get_machine_minimum_fees(&self) -> Result<MemPoolMinFees>;
 }

rpc/src/v1/types/mem_pool.rs

@@ -0,0 +1,51 @@
+// Copyright 2020 Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MemPoolMinFees {
+    min_pay_transaction_cost: u64,
+    min_set_regular_key_transaction_cost: u64,
+    min_create_shard_transaction_cost: u64,
+    min_set_shard_owners_transaction_cost: u64,
+    min_set_shard_users_transaction_cost: u64,
+    min_wrap_ccc_transaction_cost: u64,
+    min_custom_transaction_cost: u64,
+    min_asset_mint_cost: u64,
+    min_asset_transfer_cost: u64,
+    min_asset_scheme_change_cost: u64,
+    min_asset_supply_increase_cost: u64,
+    min_asset_unwrap_ccc_cost: u64,
+}
+
+impl From<ccore::MemPoolMinFees> for MemPoolMinFees {
+    fn from(fees: ccore::MemPoolMinFees) -> Self {
+        Self {
+            min_pay_transaction_cost: fees.min_pay_transaction_cost,
+            min_set_regular_key_transaction_cost: fees.min_set_regular_key_transaction_cost,
+            min_create_shard_transaction_cost: fees.min_create_shard_transaction_cost,
+            min_set_shard_owners_transaction_cost: fees.min_set_shard_owners_transaction_cost,
+            min_set_shard_users_transaction_cost: fees.min_set_shard_users_transaction_cost,
+            min_wrap_ccc_transaction_cost: fees.min_wrap_ccc_transaction_cost,
+            min_custom_transaction_cost: fees.min_custom_transaction_cost,
+            min_asset_mint_cost: fees.min_asset_mint_cost,
+            min_asset_transfer_cost: fees.min_asset_transfer_cost,
+            min_asset_scheme_change_cost: fees.min_asset_scheme_change_cost,
+            min_asset_supply_increase_cost: fees.min_asset_supply_increase_cost,
+            min_asset_unwrap_ccc_cost: fees.min_asset_unwrap_ccc_cost,
+        }
+    }
+}

rpc/src/v1/types/mod.rs

@@ -1,4 +1,4 @@
-// Copyright 2018-2019 Kodebox, Inc.
+// Copyright 2018-2020 Kodebox, Inc.
 // This file is part of CodeChain.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -16,13 +16,15 @@
 
 mod action;
 mod block;
+mod mem_pool;
 mod transaction;
 mod unsigned_transaction;
 mod work;
 
 pub use self::action::{Action, ActionWithTracker};
 pub use self::block::Block;
 pub use self::block::BlockNumberAndHash;
+pub use self::mem_pool::MemPoolMinFees;
 pub use self::transaction::{PendingTransactions, Transaction};
 pub use self::unsigned_transaction::UnsignedTransaction;
 pub use self::work::Work;