Implement new RPCs related banned users

Author: Seonpyo Kim

core/src/client/client.rs

@@ -20,7 +20,7 @@ use std::sync::{Arc, Weak};
 use std::time::Instant;
 
 use cio::IoChannel;
-use ckey::{Address, PlatformAddress, Public};
+use ckey::{Address, NetworkId, PlatformAddress, Public};
 use cmerkle::Result as TrieResult;
 use cnetwork::NodeId;
 use cstate::{
@@ -892,7 +892,31 @@ impl BlockProducer for Client {
     }
 }
 
-impl MiningBlockChainClient for Client {}
+impl MiningBlockChainClient for Client {
+    fn get_malicious_users(&self) -> Vec<Address> {
+        self.importer.miner.get_malicious_users()
+    }
+
+    fn release_malicious_users(&self, prisoner_vec: Vec<Address>) {
+        self.importer.miner.release_malicious_users(prisoner_vec)
+    }
+
+    fn imprison_malicious_users(&self, prisoner_vec: Vec<Address>) {
+        self.importer.miner.imprison_malicious_users(prisoner_vec)
+    }
+
+    fn get_immune_users(&self) -> Vec<Address> {
+        self.importer.miner.get_immune_users()
+    }
+
+    fn register_immune_users(&self, immune_user_vec: Vec<Address>) {
+        self.importer.miner.register_immune_users(immune_user_vec)
+    }
+
+    fn get_network_id(&self) -> NetworkId {
+        self.common_params(BlockId::Latest).unwrap().network_id()
+    }
+}
 
 impl ChainTimeInfo for Client {
     fn transaction_block_age(&self, tracker: &H256, parent_block_number: BlockNumber) -> Option<u64> {

core/src/client/mod.rs

@@ -32,7 +32,7 @@ pub use self::test_client::TestBlockChainClient;
 use std::ops::Range;
 use std::sync::Arc;
 
-use ckey::{Address, PlatformAddress, Public};
+use ckey::{Address, NetworkId, PlatformAddress, Public};
 use cmerkle::Result as TrieResult;
 use cnetwork::NodeId;
 use cstate::{AssetScheme, FindActionHandler, OwnedAsset, StateResult, Text, TopLevelState, TopStateView};
@@ -271,7 +271,25 @@ pub trait BlockProducer {
 }
 
 /// Extended client interface used for mining
-pub trait MiningBlockChainClient: BlockChainClient + BlockProducer + FindActionHandler {}
+pub trait MiningBlockChainClient: BlockChainClient + BlockProducer + FindActionHandler {
+    /// Returns malicious users who sent failing transactions.
+    fn get_malicious_users(&self) -> Vec<Address>;
+
+    /// Release designated users from the malicious user list.
+    fn release_malicious_users(&self, prisoner_vec: Vec<Address>);
+
+    /// Append designated users to the malicious user list.
+    fn imprison_malicious_users(&self, prisoner_vec: Vec<Address>);
+
+    /// Returns users immune from getting banned.
+    fn get_immune_users(&self) -> Vec<Address>;
+
+    /// Append designated users to the immune user list.
+    fn register_immune_users(&self, immune_user_vec: Vec<Address>);
+
+    /// Returns network id.
+    fn get_network_id(&self) -> NetworkId;
+}
 
 /// Provides methods to access database.
 pub trait DatabaseClient {

core/src/client/test_client.rs

@@ -362,7 +362,31 @@ impl BlockProducer for TestBlockChainClient {
     }
 }
 
-impl MiningBlockChainClient for TestBlockChainClient {}
+impl MiningBlockChainClient for TestBlockChainClient {
+    fn get_malicious_users(&self) -> Vec<Address> {
+        self.miner.get_malicious_users()
+    }
+
+    fn release_malicious_users(&self, prisoner_vec: Vec<Address>) {
+        self.miner.release_malicious_users(prisoner_vec)
+    }
+
+    fn imprison_malicious_users(&self, prisoner_vec: Vec<Address>) {
+        self.miner.imprison_malicious_users(prisoner_vec)
+    }
+
+    fn get_immune_users(&self) -> Vec<Address> {
+        self.miner.get_immune_users()
+    }
+
+    fn register_immune_users(&self, immune_user_vec: Vec<Address>) {
+        self.miner.register_immune_users(immune_user_vec)
+    }
+
+    fn get_network_id(&self) -> NetworkId {
+        NetworkId::default()
+    }
+}
 
 impl AccountData for TestBlockChainClient {
     fn seq(&self, address: &Address, id: BlockId) -> Option<u64> {

core/src/miner/miner.rs

@@ -16,6 +16,7 @@
 
 use std::collections::HashSet;
 use std::iter::once;
+use std::iter::FromIterator;
 use std::ops::Range;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
@@ -1123,6 +1124,35 @@ impl MinerService for Miner {
         cdebug!(MINER, "Stop sealing");
         self.sealing_enabled.store(false, Ordering::Relaxed);
     }
+
+    fn get_malicious_users(&self) -> Vec<Address> {
+        Vec::from_iter(self.malicious_users.read().iter().map(Clone::clone))
+    }
+
+    fn release_malicious_users(&self, prisoner_vec: Vec<Address>) {
+        let mut malicious_users = self.malicious_users.write();
+        for address in prisoner_vec {
+            malicious_users.remove(&address);
+        }
+    }
+
+    fn imprison_malicious_users(&self, prisoner_vec: Vec<Address>) {
+        let mut malicious_users = self.malicious_users.write();
+        for address in prisoner_vec {
+            malicious_users.insert(address);
+        }
+    }
+
+    fn get_immune_users(&self) -> Vec<Address> {
+        Vec::from_iter(self.immune_users.read().iter().map(Clone::clone))
+    }
+
+    fn register_immune_users(&self, immune_user_vec: Vec<Address>) {
+        let mut immune_users = self.immune_users.write();
+        for address in immune_user_vec {
+            immune_users.insert(address);
+        }
+    }
 }
 
 fn get_next_seq(transactions: impl IntoIterator<Item = SignedTransaction>, addresses: &[Address]) -> Option<u64> {

core/src/miner/mod.rs

@@ -150,6 +150,21 @@ pub trait MinerService: Send + Sync {
 
     /// Stop sealing.
     fn stop_sealing(&self);
+
+    /// Get malicious users
+    fn get_malicious_users(&self) -> Vec<Address>;
+
+    /// Release target malicious users from malicious user set.
+    fn release_malicious_users(&self, prisoner_vec: Vec<Address>);
+
+    /// Imprison target malicious users to malicious user set.
+    fn imprison_malicious_users(&self, prisoner_vec: Vec<Address>);
+
+    /// Get ban-immune users.
+    fn get_immune_users(&self) -> Vec<Address>;
+
+    /// Register users to ban-immune users.
+    fn register_immune_users(&self, immune_user_vec: Vec<Address>);
 }
 
 /// Mining status

rpc/src/v1/impls/mempool.rs

@@ -16,8 +16,9 @@
 
 use std::sync::Arc;
 
-use ccore::{BlockChainClient, SignedTransaction};
+use ccore::{BlockChainClient, MiningBlockChainClient, SignedTransaction};
 use cjson::bytes::Bytes;
+use ckey::{Address, PlatformAddress};
 use primitives::H256;
 use rlp::UntrustedRlp;
 
@@ -41,7 +42,7 @@ impl<C> MempoolClient<C> {
 
 impl<C> Mempool for MempoolClient<C>
 where
-    C: BlockChainClient + 'static,
+    C: BlockChainClient + MiningBlockChainClient + 'static,
 {
     fn send_signed_transaction(&self, raw: Bytes) -> Result<H256> {
         UntrustedRlp::new(&raw.into_vec())
@@ -78,4 +79,37 @@ where
     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_banned_accounts(&self) -> Result<Vec<PlatformAddress>> {
+        let malicious_user_vec = self.client.get_malicious_users();
+        let network_id = self.client.get_network_id();
+        Ok(malicious_user_vec.into_iter().map(|address| PlatformAddress::new_v1(network_id, address)).collect())
+    }
+
+    fn unban_accounts(&self, prisoner_list: Vec<PlatformAddress>) -> Result<()> {
+        let prisoner_vec: Vec<Address> = prisoner_list.into_iter().map(PlatformAddress::into_address).collect();
+
+        self.client.release_malicious_users(prisoner_vec);
+        Ok(())
+    }
+
+    fn ban_accounts(&self, prisoner_list: Vec<PlatformAddress>) -> Result<()> {
+        let prisoner_vec: Vec<Address> = prisoner_list.into_iter().map(PlatformAddress::into_address).collect();
+
+        self.client.imprison_malicious_users(prisoner_vec);
+        Ok(())
+    }
+
+    fn get_immune_accounts(&self) -> Result<Vec<PlatformAddress>> {
+        let immune_user_vec = self.client.get_immune_users();
+        let network_id = self.client.get_network_id();
+        Ok(immune_user_vec.into_iter().map(|address| PlatformAddress::new_v1(network_id, address)).collect())
+    }
+
+    fn register_immune_accounts(&self, immune_user_list: Vec<PlatformAddress>) -> Result<()> {
+        let immune_user_vec: Vec<Address> = immune_user_list.into_iter().map(PlatformAddress::into_address).collect();
+
+        self.client.register_immune_users(immune_user_vec);
+        Ok(())
+    }
 }

rpc/src/v1/traits/mempool.rs

@@ -17,6 +17,7 @@
 use cjson::bytes::Bytes;
 use primitives::H256;
 
+use ckey::PlatformAddress;
 use jsonrpc_core::Result;
 
 use super::super::types::PendingTransactions;
@@ -42,5 +43,20 @@ build_rpc_trait! {
        /// 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(name = "mempool_getBannedAccounts")]
+        fn get_banned_accounts(&self) -> Result<Vec<PlatformAddress>>;
+
+        #[rpc(name = "mempool_unbanAccounts")]
+        fn unban_accounts(&self, Vec<PlatformAddress>) -> Result<()>;
+
+        #[rpc(name = "mempool_banAccounts")]
+        fn ban_accounts(&self, Vec<PlatformAddress>) -> Result<()>;
+
+        #[rpc(name = "mempool_getImmuneAccounts")]
+        fn get_immune_accounts(&self) -> Result<Vec<PlatformAddress>>;
+
+        #[rpc(name = "mempool_registerImmuneAccounts")]
+        fn register_immune_accounts(&self, Vec<PlatformAddress>) -> Result<()>;
     }
 }