Create a new RPC category named mempool

It contains
1. mempool_sendSignedTransaction
2. mempool_getErrorHint
3. mempool_getTransactionResultsByTracker
4. mempool_getPendingTransactions
5. mempool_getPendingTransactionsCount

Author: Seulgi Kim

codechain/rpc_apis.rs

@@ -33,7 +33,8 @@ pub struct ApiDependencies {
 impl ApiDependencies {
     pub fn extend_api(&self, enable_devel_api: bool, handler: &mut MetaIoHandler<(), impl Middleware<()>>) {
         use crpc::v1::*;
-        handler.extend_with(ChainClient::new(Arc::clone(&self.client), Arc::clone(&self.miner)).to_delegate());
+        handler.extend_with(ChainClient::new(Arc::clone(&self.client)).to_delegate());
+        handler.extend_with(MempoolClient::new(Arc::clone(&self.client), Arc::clone(&self.miner)).to_delegate());
         if enable_devel_api {
             handler.extend_with(
                 DevelClient::new(Arc::clone(&self.client), Arc::clone(&self.miner), self.block_sync.clone())

rpc/src/v1/impls/chain.rs

@@ -17,36 +17,30 @@
 use std::sync::Arc;
 
 use ccore::{
-    AssetClient, BlockId, EngineInfo, ExecuteClient, MinerService, MiningBlockChainClient, RegularKey, RegularKeyOwner,
-    Shard, SignedTransaction, TextClient,
+    AssetClient, BlockId, EngineInfo, ExecuteClient, MiningBlockChainClient, RegularKey, RegularKeyOwner, Shard,
+    TextClient,
 };
 use ccrypto::Blake;
-use cjson::bytes::Bytes;
 use cjson::uint::Uint;
 use ckey::{public_to_address, NetworkId, PlatformAddress, Public};
 use cstate::FindActionHandler;
 use ctypes::transaction::{Action, ShardTransaction as ShardTransactionType};
 use ctypes::{BlockNumber, ShardId};
 use primitives::{Bytes as BytesArray, H160, H256};
-use rlp::UntrustedRlp;
 
 use jsonrpc_core::Result;
 
 use super::super::errors;
 use super::super::traits::Chain;
-use super::super::types::{
-    AssetScheme, Block, BlockNumberAndHash, OwnedAsset, PendingTransactions, Text, Transaction, UnsignedTransaction,
-};
+use super::super::types::{AssetScheme, Block, BlockNumberAndHash, OwnedAsset, Text, Transaction, UnsignedTransaction};
 
-pub struct ChainClient<C, M>
+pub struct ChainClient<C>
 where
-    C: AssetClient + MiningBlockChainClient + Shard + RegularKey + RegularKeyOwner + ExecuteClient + EngineInfo,
-    M: MinerService, {
+    C: AssetClient + MiningBlockChainClient + Shard + RegularKey + RegularKeyOwner + ExecuteClient + EngineInfo, {
     client: Arc<C>,
-    miner: Arc<M>,
 }
 
-impl<C, M> ChainClient<C, M>
+impl<C> ChainClient<C>
 where
     C: AssetClient
         + MiningBlockChainClient
@@ -56,17 +50,15 @@ where
         + ExecuteClient
         + EngineInfo
         + TextClient,
-    M: MinerService,
 {
-    pub fn new(client: Arc<C>, miner: Arc<M>) -> Self {
+    pub fn new(client: Arc<C>) -> Self {
         ChainClient {
             client,
-            miner,
         }
     }
 }
 
-impl<C, M> Chain for ChainClient<C, M>
+impl<C> Chain for ChainClient<C>
 where
     C: AssetClient
         + MiningBlockChainClient
@@ -78,20 +70,7 @@ where
         + FindActionHandler
         + TextClient
         + 'static,
-    M: MinerService + 'static,
 {
-    fn send_signed_transaction(&self, raw: Bytes) -> Result<H256> {
-        UntrustedRlp::new(&raw.into_vec())
-            .as_val()
-            .map_err(|e| errors::rlp(&e))
-            .and_then(|tx| SignedTransaction::try_new(tx).map_err(errors::transaction_core))
-            .and_then(|signed| {
-                let hash = signed.hash();
-                self.miner.import_own_transaction(&*self.client, signed).map_err(errors::transaction_core).map(|_| hash)
-            })
-            .map(Into::into)
-    }
-
     fn get_transaction(&self, transaction_hash: H256) -> Result<Option<Transaction>> {
         let id = transaction_hash.into();
         Ok(self.client.transaction(&id).map(From::from))
@@ -105,15 +84,6 @@ where
         Ok(self.client.transaction_by_tracker(&tracker).map(From::from))
     }
 
-    fn get_transaction_results_by_tracker(&self, tracker: H256) -> Result<Vec<bool>> {
-        Ok(self
-            .client
-            .error_hints_by_tracker(&tracker)
-            .into_iter()
-            .map(|(_hash, error_hint)| error_hint.is_none())
-            .collect())
-    }
-
     fn get_asset_scheme_by_tracker(
         &self,
         tracker: H256,
@@ -183,10 +153,6 @@ where
         Ok(self.client.balance(address, block_id.into()).map(Into::into))
     }
 
-    fn get_error_hint(&self, transaction_hash: H256) -> Result<Option<String>> {
-        Ok(self.client.error_hint(&transaction_hash))
-    }
-
     fn get_regular_key(&self, address: PlatformAddress, block_number: Option<u64>) -> Result<Option<Public>> {
         let block_id = block_number.map(BlockId::Number).unwrap_or(BlockId::Latest);
         let address = address.try_address().map_err(errors::core)?;
@@ -269,14 +235,6 @@ where
         Ok(self.client.block(&BlockId::Hash(block_hash)).map(|block| block.transactions_count()))
     }
 
-    fn get_pending_transactions(&self, from: Option<u64>, to: Option<u64>) -> Result<PendingTransactions> {
-        Ok(self.client.ready_transactions(from.unwrap_or(0)..to.unwrap_or(::std::u64::MAX)).into())
-    }
-
-    fn get_pending_transactions_count(&self, from: Option<u64>, to: Option<u64>) -> Result<usize> {
-        Ok(self.client.count_pending_transactions(from.unwrap_or(0)..to.unwrap_or(::std::u64::MAX)))
-    }
-
     fn get_mining_reward(&self, block_number: u64) -> Result<Option<u64>> {
         Ok(self.client.mining_reward(block_number))
     }

rpc/src/v1/impls/mempool.rs

@@ -0,0 +1,88 @@
+// Copyright 2019 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/>.
+
+use std::sync::Arc;
+
+use ccore::{MinerService, MiningBlockChainClient, SignedTransaction};
+use cjson::bytes::Bytes;
+use primitives::H256;
+use rlp::UntrustedRlp;
+
+use jsonrpc_core::Result;
+
+use super::super::errors;
+use super::super::traits::Mempool;
+use super::super::types::PendingTransactions;
+
+pub struct MempoolClient<C, M>
+where
+    C: MiningBlockChainClient,
+    M: MinerService, {
+    client: Arc<C>,
+    miner: Arc<M>,
+}
+
+impl<C, M> MempoolClient<C, M>
+where
+    C: MiningBlockChainClient,
+    M: MinerService,
+{
+    pub fn new(client: Arc<C>, miner: Arc<M>) -> Self {
+        MempoolClient {
+            client,
+            miner,
+        }
+    }
+}
+
+impl<C, M> Mempool for MempoolClient<C, M>
+where
+    C: MiningBlockChainClient + 'static,
+    M: MinerService + 'static,
+{
+    fn send_signed_transaction(&self, raw: Bytes) -> Result<H256> {
+        UntrustedRlp::new(&raw.into_vec())
+            .as_val()
+            .map_err(|e| errors::rlp(&e))
+            .and_then(|tx| SignedTransaction::try_new(tx).map_err(errors::transaction_core))
+            .and_then(|signed| {
+                let hash = signed.hash();
+                self.miner.import_own_transaction(&*self.client, signed).map_err(errors::transaction_core).map(|_| hash)
+            })
+            .map(Into::into)
+    }
+
+    fn get_transaction_results_by_tracker(&self, tracker: H256) -> Result<Vec<bool>> {
+        Ok(self
+            .client
+            .error_hints_by_tracker(&tracker)
+            .into_iter()
+            .map(|(_hash, error_hint)| error_hint.is_none())
+            .collect())
+    }
+
+    fn get_error_hint(&self, transaction_hash: H256) -> Result<Option<String>> {
+        Ok(self.client.error_hint(&transaction_hash))
+    }
+
+    fn get_pending_transactions(&self, from: Option<u64>, to: Option<u64>) -> Result<PendingTransactions> {
+        Ok(self.client.ready_transactions(from.unwrap_or(0)..to.unwrap_or(::std::u64::MAX)).into())
+    }
+
+    fn get_pending_transactions_count(&self, from: Option<u64>, to: Option<u64>) -> Result<usize> {
+        Ok(self.client.count_pending_transactions(from.unwrap_or(0)..to.unwrap_or(::std::u64::MAX)))
+    }
+}

rpc/src/v1/impls/mod.rs

@@ -18,12 +18,14 @@ mod account;
 mod chain;
 mod devel;
 mod engine;
+mod mempool;
 mod miner;
 mod net;
 
 pub use self::account::AccountClient;
 pub use self::chain::ChainClient;
 pub use self::devel::DevelClient;
 pub use self::engine::EngineClient;
+pub use self::mempool::MempoolClient;
 pub use self::miner::MinerClient;
 pub use self::net::NetClient;

rpc/src/v1/traits/chain.rs

@@ -14,24 +14,17 @@
 // 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 cjson::bytes::Bytes;
 use cjson::uint::Uint;
 use ckey::{NetworkId, PlatformAddress, Public};
 use ctypes::{BlockNumber, ShardId};
 use primitives::{Bytes as BytesArray, H160, H256};
 
 use jsonrpc_core::Result;
 
-use super::super::types::{
-    AssetScheme, Block, BlockNumberAndHash, OwnedAsset, PendingTransactions, Text, Transaction, UnsignedTransaction,
-};
+use super::super::types::{AssetScheme, Block, BlockNumberAndHash, OwnedAsset, Text, Transaction, UnsignedTransaction};
 
 build_rpc_trait! {
     pub trait Chain {
-        /// Sends signed transaction, returning its hash.
-        # [rpc(name = "chain_sendSignedTransaction")]
-        fn send_signed_transaction(&self, Bytes) -> Result<H256>;
-
         /// Gets transaction with given hash.
         # [rpc(name = "chain_getTransaction")]
         fn get_transaction(&self, H256) -> Result<Option<Transaction>>;
@@ -44,10 +37,6 @@ build_rpc_trait! {
         # [rpc(name = "chain_getTransactionByTracker")]
         fn get_transaction_by_tracker(&self, H256) -> Result<Option<Transaction>>;
 
-        /// Gets transaction results with given transaction tracker.
-        # [rpc(name = "chain_getTransactionResultsByTracker")]
-        fn get_transaction_results_by_tracker(&self, H256) -> Result<Vec<bool>>;
-
         /// Gets asset scheme with given transaction tracker.
         # [rpc(name = "chain_getAssetSchemeByTracker")]
         fn get_asset_scheme_by_tracker(&self, H256, ShardId, Option<u64>) -> Result<Option<AssetScheme>>;
@@ -76,10 +65,6 @@ build_rpc_trait! {
         # [rpc(name = "chain_getBalance")]
         fn get_balance(&self, PlatformAddress, Option<u64>) -> Result<Option<Uint>>;
 
-        /// Gets a hint to find out why the transaction failed.
-        # [rpc(name = "chain_getErrorHint")]
-        fn get_error_hint(&self, H256) -> Result<Option<String>>;
-
         /// Gets regular key with given account
         # [rpc(name = "chain_getRegularKey")]
         fn get_regular_key(&self, PlatformAddress, Option<u64>) -> Result<Option<Public>>;
@@ -136,14 +121,6 @@ build_rpc_trait! {
          # [rpc(name = "chain_getBlockTransactionCountByHash")]
         fn get_block_transaction_count_by_hash(&self, H256) -> Result<Option<usize>>;
 
-        /// Gets transactions in the current mem pool.
-        # [rpc(name = "chain_getPendingTransactions")]
-        fn get_pending_transactions(&self, Option<u64>, Option<u64>) -> Result<PendingTransactions>;
-
-       /// Gets the count of transactions in the current mem pool.
-        # [rpc(name = "chain_getPendingTransactionsCount")]
-        fn get_pending_transactions_count(&self, Option<u64>, Option<u64>) -> Result<usize>;
-
         /// Gets the mining given block number
         # [rpc(name = "chain_getMiningReward")]
         fn get_mining_reward(&self, u64) -> Result<Option<u64>>;

rpc/src/v1/traits/mempool.rs

@@ -0,0 +1,46 @@
+// Copyright 2019 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/>.
+
+use cjson::bytes::Bytes;
+use primitives::H256;
+
+use jsonrpc_core::Result;
+
+use super::super::types::PendingTransactions;
+
+build_rpc_trait! {
+    pub trait Mempool {
+        /// Sends signed transaction, returning its hash.
+        # [rpc(name = "mempool_sendSignedTransaction")]
+        fn send_signed_transaction(&self, Bytes) -> Result<H256>;
+
+        /// Gets transaction results with given transaction tracker.
+        # [rpc(name = "mempool_getTransactionResultsByTracker")]
+        fn get_transaction_results_by_tracker(&self, H256) -> Result<Vec<bool>>;
+
+        /// Gets a hint to find out why the transaction failed.
+        # [rpc(name = "mempool_getErrorHint")]
+        fn get_error_hint(&self, H256) -> Result<Option<String>>;
+
+        /// Gets transactions in the current mem pool.
+        # [rpc(name = "mempool_getPendingTransactions")]
+        fn get_pending_transactions(&self, Option<u64>, Option<u64>) -> Result<PendingTransactions>;
+
+       /// Gets the count of transactions in the current mem pool.
+        # [rpc(name = "mempool_getPendingTransactionsCount")]
+        fn get_pending_transactions_count(&self, Option<u64>, Option<u64>) -> Result<usize>;
+    }
+}

rpc/src/v1/traits/mod.rs

@@ -18,12 +18,14 @@ mod account;
 mod chain;
 mod devel;
 mod engine;
+mod mempool;
 mod miner;
 mod net;
 
 pub use self::account::Account;
 pub use self::chain::Chain;
 pub use self::devel::Devel;
 pub use self::engine::Engine;
+pub use self::mempool::Mempool;
 pub use self::miner::Miner;
 pub use self::net::Net;