Add a new field 'validator set root' in the header

Author: Junha Yang0

Cargo.lock

@@ -18,6 +18,7 @@ use super::invoice::Invoice;
 use crate::client::{EngineInfo, TermInfo};
 use crate::consensus::CodeChainEngine;
 use crate::error::{BlockError, Error};
+use crate::stake;
 use crate::transaction::{SignedTransaction, UnverifiedTransaction};
 use crate::BlockId;
 use ccrypto::BLAKE_NULL_RLP;
@@ -232,6 +233,16 @@ impl<'x> OpenBlock<'x> {
             e
         })?;
         self.block.header.set_state_root(state_root);
+
+        /*
+        FIXME: NextValidators entry doesn't exist in the state during static-validator-set-mode.
+        It doesn't cause a direct error since we use unwrap_or_default() here, but should be aware of such problem.
+        Remove this comment after we completely omit static-validator-set-mode.
+        */
+        let vset_raw = stake::NextValidators::load_from_state(self.block.state())?;
+        let vset = vset_raw.create_compact_validator_set();
+        self.block.header.set_next_validator_set_hash(vset.hash());
+
         Ok(())
     }
 

core/src/block.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
@@ -18,6 +18,7 @@ use super::CUSTOM_ACTION_HANDLER_ID;
 use ckey::{public_to_address, Address, Public};
 use cstate::{ActionData, ActionDataKeyBuilder, StateResult, TopLevelState, TopState, TopStateView};
 use ctypes::errors::RuntimeError;
+use ctypes::CompactValidatorSet;
 use primitives::{Bytes, H256};
 use rlp::{decode_list, encode_list, Decodable, Encodable, Rlp, RlpStream};
 use std::cmp::Ordering;
@@ -287,6 +288,10 @@ impl NextValidators {
         Ok(Self(validators))
     }
 
+    pub fn create_compact_validator_set(&self) -> CompactValidatorSet {
+        CompactValidatorSet(self.0.iter().map(|x| (*x.pubkey(), x.delegation())).collect())
+    }
+
     pub fn elect(state: &TopLevelState) -> StateResult<Self> {
         let (delegation_threshold, max_num_of_validators, min_num_of_validators, min_deposit) = {
             let metadata = state.metadata()?.expect("Metadata must exist");

core/src/consensus/stake/action_data.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
@@ -94,6 +94,11 @@ impl Header {
         self.view().transactions_root()
     }
 
+    /// Returns the transaction trie root.
+    pub fn next_validator_set_hash(&self) -> H256 {
+        self.view().next_validator_set_hash()
+    }
+
     /// Score of this block
     pub fn score(&self) -> U256 {
         self.view().score()

core/src/encoded.rs

@@ -84,6 +84,8 @@ pub enum BlockError {
     InvalidStateRoot(Mismatch<H256>),
     /// Transactions root header field is invalid.
     InvalidTransactionsRoot(Mismatch<H256>),
+    /// Next validator set hash header field is invalid.
+    InvalidNextValidatorSetHash(Mismatch<H256>),
     /// Score is out of range; this can be used as an looser error prior to getting a definitive
     /// value for score. This error needs only provide bounds of which it is out.
     ScoreOutOfBounds(OutOfBounds<U256>),
@@ -139,6 +141,7 @@ impl fmt::Display for BlockError {
             InvalidSealArity(mis) => format!("Block seal in incorrect format: {}", mis),
             InvalidStateRoot(mis) => format!("Invalid state root in header: {}", mis),
             InvalidTransactionsRoot(mis) => format!("Invalid transactions root in header: {}", mis),
+            InvalidNextValidatorSetHash(mis) => format!("Invalid next validator set hash in header: {}", mis),
             ScoreOutOfBounds(oob) => format!("Invalid block score: {}", oob),
             InvalidScore(oob) => format!("Invalid block score: {}", oob),
             InvalidProofOfWork => "Invalid proof of work.".into(),

core/src/error.rs

@@ -37,6 +37,8 @@ pub struct Genesis {
     pub transactions_root: H256,
     /// State root.
     pub state_root: Option<H256>,
+    /// Next validator set hash.
+    pub next_validator_set_hash: Option<H256>,
     /// The genesis block's extra data field.
     pub extra_data: Bytes,
 }
@@ -51,6 +53,7 @@ impl From<cjson::scheme::Genesis> for Genesis {
             parent_hash: g.parent_hash.map_or_else(H256::zero, Into::into).into(),
             transactions_root: g.transactions_root.map_or_else(|| BLAKE_NULL_RLP, Into::into),
             state_root: g.state_root.map(Into::into),
+            next_validator_set_hash: g.next_validator_set_hash.map(Into::into),
             extra_data: g.extra_data.map_or_else(Vec::new, Into::into),
         }
     }

core/src/scheme/genesis.rs

@@ -266,6 +266,7 @@ impl Scheme {
         header.set_transactions_root(self.transactions_root);
         header.set_extra_data(blake256(&self.genesis_params().rlp_bytes()).to_vec());
         header.set_state_root(self.state_root());
+        header.set_next_validator_set_hash(BLAKE_NULL_RLP /* This will be calculated from state after https://github.com/CodeChain-io/foundry/issues/142*/);
         header.set_score(self.score);
         header.set_seal({
             let r = Rlp::new(&self.seal_rlp);

core/src/scheme/scheme.rs

@@ -265,5 +265,11 @@ pub fn verify_block_final(expected: &Header, got: &Header) -> Result<(), Error>
             found: *got.state_root(),
         })))
     }
+    if expected.next_validator_set_hash() != got.next_validator_set_hash() {
+        return Err(From::from(BlockError::InvalidNextValidatorSetHash(Mismatch {
+            expected: *expected.next_validator_set_hash(),
+            found: *got.next_validator_set_hash(),
+        })))
+    }
     Ok(())
 }

core/src/verification/verification.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
@@ -70,29 +70,34 @@ impl<'a> HeaderView<'a> {
         self.rlp.val_at(3).unwrap()
     }
 
+    /// Returns next validator set hash
+    pub fn next_validator_set_hash(&self) -> H256 {
+        self.rlp.val_at(4).unwrap()
+    }
+
     /// Returns block score.
     pub fn score(&self) -> U256 {
-        self.rlp.val_at(4).unwrap()
+        self.rlp.val_at(5).unwrap()
     }
 
     /// Returns block number.
     pub fn number(&self) -> BlockNumber {
-        self.rlp.val_at(5).unwrap()
+        self.rlp.val_at(6).unwrap()
     }
 
     /// Returns timestamp.
     pub fn timestamp(&self) -> u64 {
-        self.rlp.val_at(6).unwrap()
+        self.rlp.val_at(7).unwrap()
     }
 
     /// Returns block extra data.
     pub fn extra_data(&self) -> Bytes {
-        self.rlp.val_at(7).unwrap()
+        self.rlp.val_at(8).unwrap()
     }
 
     /// Returns a vector of post-RLP-encoded seal fields.
     pub fn seal(&self) -> Vec<Bytes> {
-        const SIZE_WITHOUT_SEAL: usize = 8;
+        const SIZE_WITHOUT_SEAL: usize = 9;
 
         let item_count = self.rlp.item_count().unwrap();
         let mut seal = Vec::with_capacity(item_count - SIZE_WITHOUT_SEAL);

core/src/views/header.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
@@ -38,6 +38,8 @@ pub struct Genesis {
     pub transactions_root: Option<H256>,
     /// State root.
     pub state_root: Option<H256>,
+    /// Next validator set hash.
+    pub next_validator_set_hash: Option<H256>,
     /// Extra data.
     pub extra_data: Option<Bytes>,
 }
@@ -73,7 +75,8 @@ mod tests {
             "timestamp": "0x07",
             "parentHash": "0x9000000000000000000000000000000000000000000000000000000000000000",
             "extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
-            "stateRoot": "0xd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544"
+            "stateRoot": "0xd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544",
+            "nextValidatorSetHash": "0xd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544"
         }"#;
         let deserialized: Genesis = serde_json::from_str(s).unwrap();
         assert_eq!(deserialized, Genesis {
@@ -90,6 +93,7 @@ mod tests {
             parent_hash: Some(H256(Core256::from("0x9000000000000000000000000000000000000000000000000000000000000000"))),
             transactions_root: None,
             state_root: Some(H256(Core256::from("0xd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544"))),
+            next_validator_set_hash: Some(H256(Core256::from("0xd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544"))),
             extra_data: Some(Bytes::from_str("0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa").unwrap()),
         });
     }