Update the term id and the block id when the term changes

core/Cargo.toml

@@ -37,7 +37,6 @@ rlp_compress = { path = "../util/rlp_compress" }
 rlp_derive = { path = "../util/rlp_derive" }
 snap = "0.2"
 table = { path = "../util/table" }
-time = "0.1"
 util-error = { path = "../util/error" }
 
 [dev-dependencies]

core/src/block.rs

@@ -21,6 +21,7 @@ use ckey::Address;
 use cmerkle::skewed_merkle_root;
 use cstate::{FindActionHandler, StateDB, StateError, StateWithCache, TopLevelState};
 use ctypes::errors::HistoryError;
+use ctypes::header::{Header, Seal};
 use ctypes::util::unexpected::Mismatch;
 use ctypes::{BlockNumber, CommonParams};
 use cvm::ChainTimeInfo;
@@ -31,7 +32,6 @@ use super::invoice::Invoice;
 use crate::client::EngineInfo;
 use crate::consensus::CodeChainEngine;
 use crate::error::{BlockError, Error};
-use crate::header::{Header, Seal};
 use crate::transaction::{SignedTransaction, UnverifiedTransaction};
 
 /// A block, encoded as it is on the block chain.
@@ -216,23 +216,30 @@ impl<'x> OpenBlock<'x> {
     }
 
     /// Turn this into a `ClosedBlock`.
-    pub fn close(
-        mut self,
-        parent_transactions_root: H256,
-        parent_common_params: &CommonParams,
-    ) -> Result<ClosedBlock, Error> {
+    pub fn close(mut self, parent_header: &Header, parent_common_params: &CommonParams) -> Result<ClosedBlock, Error> {
         let unclosed_state = self.block.state.clone();
 
-        if let Err(e) = self.engine.on_close_block(&mut self.block, parent_common_params) {
+        if let Err(e) = self.engine.on_close_block(&mut self.block, parent_header, parent_common_params) {
             warn!("Encountered error on closing the block: {}", e);
             return Err(e)
         }
+        let header = self.block.header().clone();
+        for handler in self.engine.action_handlers() {
+            handler.on_close_block(self.block.state_mut(), &header, parent_header, parent_common_params).map_err(
+                |e| {
+                    warn!("Encountered error in {}::on_close_block", handler.name());
+                    e
+                },
+            )?;
+        }
+
         let state_root = self.block.state.commit().map_err(|e| {
             warn!("Encountered error on state commit: {}", e);
             e
         })?;
+        let parent_transactions_root = parent_header.transactions_root();
         self.block.header.set_transactions_root(skewed_merkle_root(
-            parent_transactions_root,
+            *parent_transactions_root,
             self.block.transactions.iter().map(Encodable::rlp_bytes),
         ));
         self.block.header.set_state_root(state_root);
@@ -246,27 +253,37 @@ impl<'x> OpenBlock<'x> {
     /// Turn this into a `LockedBlock`.
     pub fn close_and_lock(
         mut self,
-        parent_transactions_root: H256,
+        parent_header: &Header,
         parent_common_params: &CommonParams,
     ) -> Result<LockedBlock, Error> {
-        if let Err(e) = self.engine.on_close_block(&mut self.block, parent_common_params) {
+        if let Err(e) = self.engine.on_close_block(&mut self.block, parent_header, parent_common_params) {
             warn!("Encountered error on closing the block: {}", e);
             return Err(e)
         }
+        let header = self.block.header().clone();
+        for handler in self.engine.action_handlers() {
+            handler.on_close_block(self.block.state_mut(), &header, parent_header, parent_common_params).map_err(
+                |e| {
+                    warn!("Encountered error in {}::on_close_block", handler.name());
+                    e
+                },
+            )?;
+        }
 
         let state_root = self.block.state.commit().map_err(|e| {
             warn!("Encountered error on state commit: {}", e);
             e
         })?;
+        let parent_transactions_root = parent_header.transactions_root();
         if self.block.header.transactions_root().is_zero() || self.block.header.transactions_root() == &BLAKE_NULL_RLP {
             self.block.header.set_transactions_root(skewed_merkle_root(
-                parent_transactions_root,
+                *parent_transactions_root,
                 self.block.transactions.iter().map(Encodable::rlp_bytes),
             ));
         }
         debug_assert_eq!(
             self.block.header.transactions_root(),
-            &skewed_merkle_root(parent_transactions_root, self.block.transactions.iter().map(Encodable::rlp_bytes),)
+            &skewed_merkle_root(*parent_transactions_root, self.block.transactions.iter().map(Encodable::rlp_bytes),)
         );
         self.block.header.set_state_root(state_root);
 
@@ -451,7 +468,7 @@ pub fn enact<C: ChainTimeInfo + EngineInfo + FindActionHandler>(
     b.push_transactions(transactions, client, parent.number(), parent.timestamp())?;
 
     let parent_common_params = client.common_params((*header.parent_hash()).into()).unwrap();
-    b.close_and_lock(*parent.transactions_root(), &parent_common_params)
+    b.close_and_lock(parent, &parent_common_params)
 }
 
 #[cfg(test)]
@@ -469,9 +486,8 @@ mod tests {
         let genesis_header = scheme.genesis_header();
         let db = scheme.ensure_genesis_state(get_temp_state_db()).unwrap();
         let b = OpenBlock::try_new(&*scheme.engine, db, &genesis_header, Address::default(), vec![]).unwrap();
-        let parent_transactions_root = *genesis_header.transactions_root();
         let parent_common_params = CommonParams::default_for_test();
-        let b = b.close_and_lock(parent_transactions_root, &parent_common_params).unwrap();
+        let b = b.close_and_lock(&genesis_header, &parent_common_params).unwrap();
         let _ = b.seal(&*scheme.engine, vec![]);
     }
 }

core/src/blockchain/headerchain.rs

@@ -18,6 +18,7 @@ use std::collections::HashMap;
 use std::mem;
 use std::sync::Arc;
 
+use ctypes::header::{Header, Seal};
 use ctypes::BlockNumber;
 use kvdb::{DBTransaction, KeyValueDB};
 use parking_lot::{Mutex, RwLock};
@@ -30,7 +31,6 @@ use super::route::tree_route;
 use crate::consensus::CodeChainEngine;
 use crate::db::{self, CacheUpdatePolicy, Readable, Writable};
 use crate::encoded;
-use crate::header::{Header, Seal};
 use crate::views::HeaderView;
 
 const BEST_HEADER_KEY: &[u8] = b"best-header";

core/src/client/importer.rs

@@ -20,6 +20,7 @@ use std::sync::Arc;
 use std::time::Instant;
 
 use cio::IoChannel;
+use ctypes::header::Header;
 use kvdb::DBTransaction;
 use parking_lot::{Mutex, MutexGuard};
 use primitives::H256;
@@ -31,7 +32,6 @@ use crate::blockchain::{BodyProvider, HeaderProvider, ImportRoute};
 use crate::consensus::CodeChainEngine;
 use crate::encoded;
 use crate::error::Error;
-use crate::header::Header;
 use crate::miner::{Miner, MinerService};
 use crate::service::ClientIoMessage;
 use crate::types::BlockId;

core/src/client/test_client.rs

@@ -42,7 +42,7 @@ use cnetwork::NodeId;
 use cstate::{FindActionHandler, StateDB};
 use ctimer::{TimeoutHandler, TimerToken};
 use ctypes::transaction::{Action, Transaction};
-use ctypes::{BlockNumber, CommonParams};
+use ctypes::{BlockNumber, CommonParams, Header as BlockHeader};
 use cvm::ChainTimeInfo;
 use journaldb;
 use kvdb::KeyValueDB;
@@ -61,7 +61,6 @@ use crate::client::{
 use crate::db::{COL_STATE, NUM_COLUMNS};
 use crate::encoded;
 use crate::error::BlockImportError;
-use crate::header::Header as BlockHeader;
 use crate::miner::{Miner, MinerService, TransactionImportResult};
 use crate::scheme::Scheme;
 use crate::transaction::{LocalizedTransaction, PendingSignedTransactions, SignedTransaction};

core/src/codechain_machine.rs

@@ -19,12 +19,11 @@ use ckey::Address;
 use cstate::{StateError, TopState, TopStateView};
 use ctypes::errors::{HistoryError, SyntaxError};
 use ctypes::transaction::{Action, AssetTransferInput, OrderOnTransfer, Timelock};
-use ctypes::CommonParams;
+use ctypes::{CommonParams, Header};
 
 use crate::block::{ExecutedBlock, IsBlock};
 use crate::client::BlockChainTrait;
 use crate::error::Error;
-use crate::header::Header;
 use crate::transaction::{SignedTransaction, UnverifiedTransaction};
 
 pub struct CodeChainMachine {
@@ -251,6 +250,16 @@ impl CodeChainMachine {
         live.state_mut().add_balance(address, amount).map_err(StateError::from)?;
         Ok(())
     }
+
+    pub fn change_term_id(
+        &self,
+        live: &mut ExecutedBlock,
+        last_term_finished_block_num: u64,
+        current_term_id: u64,
+    ) -> Result<(), Error> {
+        live.state_mut().change_term_id(last_term_finished_block_num, current_term_id)?;
+        Ok(())
+    }
 }
 
 fn is_order_disabled() -> bool {

core/src/consensus/blake_pow/mod.rs

@@ -20,7 +20,7 @@ use std::cmp::{max, min};
 
 use ccrypto::blake256;
 use ctypes::util::unexpected::{Mismatch, OutOfBounds};
-use ctypes::CommonParams;
+use ctypes::{CommonParams, Header};
 use primitives::U256;
 use rlp::UntrustedRlp;
 
@@ -30,7 +30,6 @@ use crate::block::ExecutedBlock;
 use crate::codechain_machine::CodeChainMachine;
 use crate::consensus::EngineType;
 use crate::error::{BlockError, Error};
-use crate::header::Header;
 
 /// BlakePoW specific seal
 #[derive(Debug, PartialEq)]
@@ -160,7 +159,12 @@ impl ConsensusEngine for BlakePoW {
         header.set_score(score);
     }
 
-    fn on_close_block(&self, block: &mut ExecutedBlock, _parent_common_params: &CommonParams) -> Result<(), Error> {
+    fn on_close_block(
+        &self,
+        block: &mut ExecutedBlock,
+        _parent_header: &Header,
+        _parent_common_params: &CommonParams,
+    ) -> Result<(), Error> {
         let author = *block.header().author();
         let total_reward = self.block_reward(block.header().number())
             + self.block_fee(Box::new(block.transactions().to_owned().into_iter().map(Into::into)));

core/src/consensus/cuckoo/mod.rs

@@ -20,7 +20,7 @@ use std::cmp::{max, min};
 
 use ccrypto::blake256;
 use ctypes::util::unexpected::{Mismatch, OutOfBounds};
-use ctypes::CommonParams;
+use ctypes::{CommonParams, Header};
 use cuckoo::Cuckoo as CuckooVerifier;
 use primitives::U256;
 use rlp::UntrustedRlp;
@@ -31,7 +31,6 @@ use crate::block::ExecutedBlock;
 use crate::codechain_machine::CodeChainMachine;
 use crate::consensus::EngineType;
 use crate::error::{BlockError, Error};
-use crate::header::Header;
 
 /// Cuckoo specific seal
 #[derive(Debug, PartialEq)]
@@ -170,7 +169,12 @@ impl ConsensusEngine for Cuckoo {
         header.set_score(score);
     }
 
-    fn on_close_block(&self, block: &mut ExecutedBlock, _parent_common_params: &CommonParams) -> Result<(), Error> {
+    fn on_close_block(
+        &self,
+        block: &mut ExecutedBlock,
+        _parent_header: &Header,
+        _parent_common_params: &CommonParams,
+    ) -> Result<(), Error> {
         let author = *block.header().author();
         let total_reward = self.block_reward(block.header().number())
             + self.block_fee(Box::new(block.transactions().to_owned().into_iter().map(Into::into)));
@@ -251,13 +255,14 @@ mod tests {
     #[test]
     fn on_close_block() {
         let scheme = Scheme::new_test_cuckoo();
+        let genesis_header = scheme.genesis_header();
         let engine = &*scheme.engine;
         let db = scheme.ensure_genesis_state(get_temp_state_db()).unwrap();
         let header = Header::default();
         let block = OpenBlock::try_new(engine, db, &header, Default::default(), vec![]).unwrap();
         let mut executed_block = block.block().clone();
 
-        assert!(engine.on_close_block(&mut executed_block, &CommonParams::default_for_test()).is_ok());
+        assert!(engine.on_close_block(&mut executed_block, &genesis_header, &CommonParams::default_for_test()).is_ok());
         assert_eq!(0xd, engine.machine().balance(&executed_block, header.author()).unwrap());
     }
 

core/src/consensus/mod.rs

@@ -43,7 +43,7 @@ use cstate::ActionHandler;
 use ctypes::errors::SyntaxError;
 use ctypes::transaction::Action;
 use ctypes::util::unexpected::{Mismatch, OutOfBounds};
-use ctypes::CommonParams;
+use ctypes::{CommonParams, Header};
 use primitives::{Bytes, H256, U256};
 
 use self::tendermint::types::{BitSet, View};
@@ -53,7 +53,6 @@ use crate::client::EngineClient;
 use crate::codechain_machine::CodeChainMachine;
 use crate::encoded;
 use crate::error::Error;
-use crate::header::Header;
 use crate::transaction::UnverifiedTransaction;
 use crate::views::HeaderView;
 use Client;
@@ -213,7 +212,12 @@ pub trait ConsensusEngine: Sync + Send {
     fn stop(&self) {}
 
     /// Block transformation functions, after the transactions.
-    fn on_close_block(&self, _block: &mut ExecutedBlock, _parent_common_params: &CommonParams) -> Result<(), Error> {
+    fn on_close_block(
+        &self,
+        _block: &mut ExecutedBlock,
+        _parent_header: &Header,
+        _parent_common_params: &CommonParams,
+    ) -> Result<(), Error> {
         Ok(())
     }
 

core/src/consensus/null_engine/mod.rs

@@ -16,7 +16,7 @@
 
 mod params;
 
-use ctypes::CommonParams;
+use ctypes::{CommonParams, Header};
 
 use self::params::NullEngineParams;
 use super::ConsensusEngine;
@@ -54,7 +54,12 @@ impl ConsensusEngine for NullEngine {
         EngineType::Solo
     }
 
-    fn on_close_block(&self, block: &mut ExecutedBlock, _parent_common_params: &CommonParams) -> Result<(), Error> {
+    fn on_close_block(
+        &self,
+        block: &mut ExecutedBlock,
+        _parent_header: &Header,
+        _parent_common_params: &CommonParams,
+    ) -> Result<(), Error> {
         let (author, total_reward) = {
             let header = block.header();
             let author = *header.author();

core/src/consensus/simple_poa/mod.rs

@@ -19,7 +19,7 @@ mod params;
 use std::sync::{Arc, Weak};
 
 use ckey::{public_to_address, recover, Address, Signature};
-use ctypes::CommonParams;
+use ctypes::{CommonParams, Header};
 use parking_lot::RwLock;
 
 use self::params::SimplePoAParams;
@@ -33,7 +33,6 @@ use crate::client::EngineClient;
 use crate::codechain_machine::CodeChainMachine;
 use crate::consensus::EngineType;
 use crate::error::{BlockError, Error};
-use crate::header::Header;
 
 pub struct SimplePoA {
     machine: CodeChainMachine,
@@ -114,7 +113,12 @@ impl ConsensusEngine for SimplePoA {
         verify_external(header, &*self.validators)
     }
 
-    fn on_close_block(&self, block: &mut ExecutedBlock, _parent_common_params: &CommonParams) -> Result<(), Error> {
+    fn on_close_block(
+        &self,
+        block: &mut ExecutedBlock,
+        _parent_header: &Header,
+        _parent_common_params: &CommonParams,
+    ) -> Result<(), Error> {
         let author = *block.header().author();
         let total_reward = self.block_reward(block.header().number())
             + self.block_fee(Box::new(block.transactions().to_owned().into_iter().map(Into::into)));
@@ -170,9 +174,8 @@ mod tests {
         let db = scheme.ensure_genesis_state(get_temp_state_db()).unwrap();
         let genesis_header = scheme.genesis_header();
         let b = OpenBlock::try_new(engine, db, &genesis_header, Default::default(), vec![]).unwrap();
-        let parent_transactions_root = *genesis_header.transactions_root();
         let parent_common_params = CommonParams::default_for_test();
-        let b = b.close_and_lock(parent_transactions_root, &parent_common_params).unwrap();
+        let b = b.close_and_lock(&genesis_header, &parent_common_params).unwrap();
         if let Some(seal) = engine.generate_seal(b.block(), &genesis_header).seal_fields() {
             assert!(b.try_seal(engine, seal).is_ok());
         }