[WIP] Remove staking logic and data from the host

coordinator/src/lib.rs

@@ -18,7 +18,7 @@
 use self::traits::{BlockExecutor, Initializer, TxFilter};
 use self::types::*;
 use context::StorageAccess;
-use ctypes::{CompactValidatorSet, ConsensusParams};
+use ctypes::{ConsensusParams, Validators};
 
 pub mod context;
 pub mod test_coordinator;
@@ -34,7 +34,7 @@ pub mod types;
 pub struct Coordinator {}
 
 impl Initializer for Coordinator {
-    fn initialize_chain(&self, app_state: String) -> (CompactValidatorSet, ConsensusParams) {
+    fn initialize_chain(&self, app_state: String) -> (Validators, ConsensusParams) {
         unimplemented!()
     }
 }

coordinator/src/test_coordinator.rs

@@ -17,12 +17,12 @@
 use super::context::StorageAccess;
 use super::traits::{BlockExecutor, Initializer, TxFilter};
 use super::types::*;
-use ctypes::{CompactValidatorSet, ConsensusParams};
+use ctypes::{ConsensusParams, Validators};
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 // Coordinator dedicated for mempool and miner testing
 pub struct TestCoordinator {
-    validator_set: CompactValidatorSet,
+    validator_set: Validators,
     consensus_params: ConsensusParams,
     body_count: AtomicUsize,
     body_size: AtomicUsize,
@@ -40,7 +40,7 @@ impl Default for TestCoordinator {
 }
 
 impl Initializer for TestCoordinator {
-    fn initialize_chain(&self, _app_state: String) -> (CompactValidatorSet, ConsensusParams) {
+    fn initialize_chain(&self, _app_state: String) -> (Validators, ConsensusParams) {
         (self.validator_set.clone(), self.consensus_params)
     }
 }

coordinator/src/traits.rs

@@ -16,10 +16,10 @@
 
 use super::context::StorageAccess;
 use super::types::*;
-use ctypes::{CompactValidatorSet, ConsensusParams};
+use ctypes::{ConsensusParams, Validators};
 
 pub trait Initializer: Send + Sync {
-    fn initialize_chain(&self, app_state: String) -> (CompactValidatorSet, ConsensusParams);
+    fn initialize_chain(&self, app_state: String) -> (Validators, ConsensusParams);
 }
 pub trait BlockExecutor: Send + Sync {
     fn open_block(

coordinator/src/types.rs

@@ -16,7 +16,7 @@
 
 use ccrypto::blake256;
 use ckey::Ed25519Public as Public;
-use ctypes::{CompactValidatorSet, ConsensusParams, TxHash};
+use ctypes::{ConsensusParams, TxHash, Validators};
 use primitives::Bytes;
 use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream};
 
@@ -239,7 +239,7 @@ pub type ExecuteTransactionError = ();
 pub type CloseBlockError = String;
 
 pub struct BlockOutcome {
-    pub updated_validator_set: Option<CompactValidatorSet>,
+    pub updated_validator_set: Option<Validators>,
     pub updated_consensus_params: Option<ConsensusParams>,
     pub events: Vec<Event>,
 }

core/src/block.rs

@@ -20,10 +20,10 @@ use ccrypto::BLAKE_NULL_RLP;
 use ckey::Ed25519Public as Public;
 use coordinator::traits::BlockExecutor;
 use coordinator::types::{Event, Header as PreHeader, Transaction, TransactionWithMetadata, VerifiedCrime};
-use cstate::{CurrentValidatorSet, NextValidatorSet, StateDB, StateError, StateWithCache, TopLevelState, TopState};
+use cstate::{CurrentValidators, NextValidators, StateDB, StateError, StateWithCache, TopLevelState, TopState};
 use ctypes::header::{Header, Seal};
 use ctypes::util::unexpected::Mismatch;
-use ctypes::{CompactValidatorSet, ConsensusParams, TxHash};
+use ctypes::{ConsensusParams, TxHash, Validators};
 use merkle_trie::skewed_merkle_root;
 use primitives::{Bytes, H256};
 use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream};
@@ -204,7 +204,7 @@ impl OpenBlock {
         let updated_validator_set = block_outcome.updated_validator_set;
         let next_validator_set_hash = match updated_validator_set {
             Some(ref set) => set.hash(),
-            None => NextValidatorSet::load_from_state(self.block.state())?.create_compact_validator_set().hash(),
+            None => NextValidators::load_from_state(self.block.state())?.hash(),
         };
         let updated_consensus_params = block_outcome.updated_consensus_params;
         if let Err(e) = self.update_next_block_state(updated_validator_set, updated_consensus_params) {
@@ -278,8 +278,8 @@ impl OpenBlock {
 
     // called on open_block
     fn update_current_validator_set(&mut self) -> Result<(), Error> {
-        let mut current_validators = CurrentValidatorSet::load_from_state(self.state())?;
-        current_validators.update(NextValidatorSet::load_from_state(self.state())?);
+        let mut current_validators = CurrentValidators::load_from_state(self.state())?;
+        current_validators.update(NextValidators::load_from_state(self.state())?.into());
         current_validators.save_to_state(self.state_mut())?;
 
         Ok(())
@@ -288,13 +288,13 @@ impl OpenBlock {
     // called on close_block
     fn update_next_block_state(
         &mut self,
-        updated_validator_set: Option<CompactValidatorSet>,
+        updated_validator_set: Option<Validators>,
         updated_consensus_params: Option<ConsensusParams>,
     ) -> Result<(), Error> {
         let state = self.block.state_mut();
 
         if let Some(set) = updated_validator_set {
-            let validators = NextValidatorSet::from_compact_validator_set(set);
+            let validators: NextValidators = set.into();
             validators.save_to_state(state)?;
         }
 

core/src/client/client.rs

@@ -40,10 +40,10 @@ use coordinator::context::{
 };
 use coordinator::traits::{BlockExecutor, Initializer};
 use coordinator::types::{Event, Transaction};
-use cstate::{Metadata, MetadataAddress, NextValidatorSet, StateDB, StateWithCache, TopLevelState, TopStateView};
+use cstate::{Metadata, MetadataAddress, NextValidators, StateDB, StateWithCache, TopLevelState, TopStateView};
 use ctimer::{TimeoutHandler, TimerApi, TimerScheduleError, TimerToken};
 use ctypes::header::Header;
-use ctypes::{BlockHash, BlockId, BlockNumber, CommonParams, CompactValidatorSet, ConsensusParams, TxHash};
+use ctypes::{BlockHash, BlockId, BlockNumber, CommonParams, ConsensusParams, TxHash, Validators};
 use kvdb::{DBTransaction, KeyValueDB};
 use merkle_trie::{TrieFactory, TrieMut};
 use parking_lot::{Mutex, RwLock, RwLockReadGuard};
@@ -236,7 +236,7 @@ impl Client {
     fn initialize_state(
         db: StateDB,
         genesis_consensus_params: ConsensusParams,
-        genesis_validators: CompactValidatorSet,
+        genesis_validators: Validators,
     ) -> Result<StateDB, Error> {
         let root = BLAKE_NULL_RLP;
         let (db, root) = Self::initialize_validator_set(db, root, genesis_validators)?;
@@ -248,10 +248,10 @@ impl Client {
     fn initialize_validator_set(
         db: StateDB,
         root: H256,
-        genesis_validators: CompactValidatorSet,
+        genesis_validators: Validators,
     ) -> Result<(StateDB, H256), Error> {
         let mut state = TopLevelState::from_existing(db.clone(&root), root)?;
-        let validator_set = NextValidatorSet::from_compact_validator_set(genesis_validators);
+        let validator_set: NextValidators = genesis_validators.into();
         validator_set.save_to_state(&mut state)?;
         let root = state.commit()?;
         Ok((db, root))

core/src/client/test_client.rs

@@ -50,12 +50,12 @@ use ckey::{Ed25519Private as Private, Ed25519Public as Public, NetworkId, Platfo
 use coordinator::test_coordinator::TestCoordinator;
 use coordinator::types::{Event, Transaction};
 use cstate::tests::helpers::empty_top_state_with_metadata;
-use cstate::{FindDoubleVoteHandler, NextValidatorSet, StateDB, TopLevelState};
+use cstate::{FindDoubleVoteHandler, NextValidators, StateDB, TopLevelState};
 use ctimer::{TimeoutHandler, TimerToken};
 use ctypes::header::Header;
 use ctypes::{
-    BlockHash, BlockId, BlockNumber, CommonParams, CompactValidatorEntry, CompactValidatorSet, ConsensusParams,
-    Header as BlockHeader, TxHash,
+    BlockHash, BlockId, BlockNumber, CommonParams, ConsensusParams, Header as BlockHeader, TxHash, Validator,
+    Validators,
 };
 use kvdb::KeyValueDB;
 use merkle_trie::skewed_merkle_root;
@@ -98,7 +98,7 @@ pub struct TestBlockChainClient {
     /// Fixed validator keys
     pub validator_keys: RwLock<HashMap<Public, Private>>,
     /// Fixed validators
-    pub validators: NextValidatorSet,
+    pub validators: NextValidators,
 }
 
 impl Default for TestBlockChainClient {
@@ -146,7 +146,7 @@ impl TestBlockChainClient {
             history: RwLock::new(None),
             term_id: Some(1),
             validator_keys: RwLock::new(HashMap::new()),
-            validators: NextValidatorSet::from_compact_validator_set(CompactValidatorSet::new(Vec::new())),
+            validators: Validators::new(Vec::new()).into(),
         };
 
         // insert genesis hash.
@@ -273,17 +273,17 @@ impl TestBlockChainClient {
             pubkeys.push(public);
         }
 
-        let compact_validator_set = CompactValidatorSet::new(
+        let compact_validator_set = Validators::new(
             pubkeys
                 .into_iter()
-                .map(|public_key| CompactValidatorEntry {
+                .map(|public_key| Validator {
                     public_key,
-                    delegation: 0,
+                    voting_power: 0,
                 })
                 .collect(),
         );
 
-        let fixed_validators: NextValidatorSet = NextValidatorSet::from_compact_validator_set(compact_validator_set);
+        let fixed_validators: NextValidators = compact_validator_set.into();
 
         self.validators = fixed_validators
     }

core/src/consensus/validator_set/dynamic_validator.rs

@@ -19,9 +19,9 @@ use crate::client::ConsensusClient;
 use crate::consensus::bit_set::BitSet;
 use crate::consensus::EngineError;
 use ckey::Ed25519Public as Public;
-use cstate::{CurrentValidatorSet, NextValidatorSet, SimpleValidator};
+use cstate::{CurrentValidators, NextValidators};
 use ctypes::util::unexpected::OutOfBounds;
-use ctypes::BlockHash;
+use ctypes::{BlockHash, Validator, Validators};
 use parking_lot::RwLock;
 use std::sync::{Arc, Weak};
 
@@ -31,31 +31,31 @@ pub struct DynamicValidator {
 }
 
 impl DynamicValidator {
-    fn next_validators(&self, hash: BlockHash) -> Vec<SimpleValidator> {
+    fn next_validators(&self, hash: BlockHash) -> Vec<Validator> {
         let client: Arc<dyn ConsensusClient> =
             self.client.read().as_ref().and_then(Weak::upgrade).expect("Client is not initialized");
         let block_id = hash.into();
         let state = client.state_at(block_id).expect("The next validators must be called on the confirmed block");
-        let validators = NextValidatorSet::load_from_state(&state).unwrap();
-        let mut validators: Vec<_> = validators.into();
+        let validators = NextValidators::load_from_state(&state).unwrap();
+        let mut validators: Vec<_> = Validators::from(validators).into();
         validators.reverse();
         validators
     }
 
-    fn current_validators(&self, hash: BlockHash) -> Vec<SimpleValidator> {
+    fn current_validators(&self, hash: BlockHash) -> Vec<Validator> {
         let client: Arc<dyn ConsensusClient> =
             self.client.read().as_ref().and_then(Weak::upgrade).expect("Client is not initialized");
         let block_id = hash.into();
         let state = client.state_at(block_id).expect("The current validators must be called on the confirmed block");
-        let validators = CurrentValidatorSet::load_from_state(&state).unwrap();
-        let mut validators: Vec<_> = validators.into();
+        let validators = CurrentValidators::load_from_state(&state).unwrap();
+        let mut validators: Vec<_> = Validators::from(validators).into();
         validators.reverse();
         validators
     }
 
     fn validators(&self, hash: BlockHash) -> Vec<Public> {
         let validators = self.next_validators(hash);
-        validators.into_iter().map(|val| *val.pubkey()).collect()
+        validators.into_iter().map(|val| val.public_key).collect()
     }
 
     pub fn proposer_index(&self, parent: BlockHash, proposed_view: usize) -> usize {
@@ -67,7 +67,7 @@ impl DynamicValidator {
     pub fn get_current(&self, hash: &BlockHash, index: usize) -> Public {
         let validators = self.current_validators(*hash);
         let n_validators = validators.len();
-        *validators.get(index % n_validators).unwrap().pubkey()
+        validators.get(index % n_validators).unwrap().public_key
     }
 
     pub fn check_enough_votes_with_current(&self, hash: &BlockHash, votes: &BitSet) -> Result<(), EngineError> {
@@ -82,9 +82,9 @@ impl DynamicValidator {
                     index,
                 }
             })?;
-            voted_weight += validator.weight();
+            voted_weight += validator.voting_power;
         }
-        let total_weight: u64 = validators.iter().map(|v| v.weight()).sum();
+        let total_weight: u64 = validators.iter().map(|v| v.voting_power).sum();
         if voted_weight * 3 > total_weight * 2 {
             Ok(())
         } else {
@@ -141,9 +141,9 @@ impl ValidatorSet for DynamicValidator {
                     index,
                 }
             })?;
-            voted_weight += validator.weight();
+            voted_weight += validator.voting_power;
         }
-        let total_weight: u64 = validators.iter().map(SimpleValidator::weight).sum();
+        let total_weight: u64 = validators.iter().map(|validator| validator.voting_power).sum();
         if voted_weight * 3 > total_weight * 2 {
             Ok(())
         } else {
@@ -164,7 +164,7 @@ impl ValidatorSet for DynamicValidator {
     }
 
     fn current_validators(&self, hash: &BlockHash) -> Vec<Public> {
-        DynamicValidator::current_validators(self, *hash).into_iter().map(|v| *v.pubkey()).collect()
+        DynamicValidator::current_validators(self, *hash).into_iter().map(|v| v.public_key).collect()
     }
 
     fn next_validators(&self, hash: &BlockHash) -> Vec<Public> {

json/src/scheme/params.rs

@@ -31,20 +31,6 @@ pub struct Params {
     pub max_body_size: Uint,
     /// Snapshot creation period in unit of block numbers.
     pub snapshot_period: Uint,
-
-    pub term_seconds: Uint,
-    pub nomination_expiration: Uint,
-    pub custody_period: Uint,
-    pub release_period: Uint,
-    pub max_num_of_validators: Uint,
-    pub min_num_of_validators: Uint,
-    pub delegation_threshold: Uint,
-    pub min_deposit: Uint,
-    pub max_candidate_metadata_size: Uint,
-
-    /// A monotonically increasing number to denote the consensus version.
-    /// It is increased when we fork.
-    pub era: Option<Uint>,
 }
 
 #[cfg(test)]
@@ -58,33 +44,14 @@ mod tests {
             "maxExtraDataSize": "0x20",
             "networkID" : "tc",
             "maxBodySize" : 4194304,
-            "snapshotPeriod": 16384,
-            "termSeconds": 3600,
-            "nominationExpiration": 24,
-            "custodyPeriod": 25,
-            "releasePeriod": 26,
-            "maxNumOfValidators": 27,
-            "minNumOfValidators": 28,
-            "delegationThreshold": 29,
-            "minDeposit": 30,
-            "maxCandidateMetadataSize": 31
+            "snapshotPeriod": 16384
         }"#;
 
         let deserialized: Params = serde_json::from_str(s).unwrap();
         assert_eq!(deserialized.max_extra_data_size, 0x20.into());
         assert_eq!(deserialized.network_id, "tc".into());
         assert_eq!(deserialized.max_body_size, 4_194_304.into());
         assert_eq!(deserialized.snapshot_period, 16_384.into());
-        assert_eq!(deserialized.term_seconds, 3600.into());
-        assert_eq!(deserialized.nomination_expiration, 24.into());
-        assert_eq!(deserialized.custody_period, 25.into());
-        assert_eq!(deserialized.release_period, 26.into());
-        assert_eq!(deserialized.max_num_of_validators, 27.into());
-        assert_eq!(deserialized.min_num_of_validators, 28.into());
-        assert_eq!(deserialized.delegation_threshold, 29.into());
-        assert_eq!(deserialized.min_deposit, 30.into());
-        assert_eq!(deserialized.max_candidate_metadata_size, 31.into());
-        assert_eq!(deserialized.era, None);
     }
 
     #[test]
@@ -94,33 +61,13 @@ mod tests {
             "maxExtraDataSize": "0x20",
             "networkID" : "tc",
             "maxBodySize" : 4194304,
-            "snapshotPeriod": 16384,
-            "termSeconds": 3600,
-            "nominationExpiration": 24,
-            "custodyPeriod": 25,
-            "releasePeriod": 26,
-            "maxNumOfValidators": 27,
-            "minNumOfValidators": 28,
-            "delegationThreshold": 29,
-            "minDeposit": 30,
-            "maxCandidateMetadataSize": 31,
-            "era": 32
+            "snapshotPeriod": 16384
         }"#;
 
         let deserialized: Params = serde_json::from_str(s).unwrap();
         assert_eq!(deserialized.max_extra_data_size, 0x20.into());
         assert_eq!(deserialized.network_id, "tc".into());
         assert_eq!(deserialized.max_body_size, 4_194_304.into());
         assert_eq!(deserialized.snapshot_period, 16_384.into());
-        assert_eq!(deserialized.term_seconds, 3600.into());
-        assert_eq!(deserialized.nomination_expiration, 24.into());
-        assert_eq!(deserialized.custody_period, 25.into());
-        assert_eq!(deserialized.release_period, 26.into());
-        assert_eq!(deserialized.max_num_of_validators, 27.into());
-        assert_eq!(deserialized.min_num_of_validators, 28.into());
-        assert_eq!(deserialized.delegation_threshold, 29.into());
-        assert_eq!(deserialized.min_deposit, 30.into());
-        assert_eq!(deserialized.max_candidate_metadata_size, 31.into());
-        assert_eq!(deserialized.era, Some(32.into()));
     }
 }