Make on_close_block receive the parent header and the parent parameters

Author: Seulgi Kim

core/src/block.rs

@@ -216,30 +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()).map_err(|e| {
-                warn!("Encountered error in {}::on_close_block", handler.name());
-                e
-            })?;
+            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);
@@ -253,33 +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()).map_err(|e| {
-                warn!("Encountered error in {}::on_close_block", handler.name());
-                e
-            })?;
+            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);
 
@@ -464,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)]
@@ -482,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/consensus/blake_pow/mod.rs

@@ -159,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

@@ -169,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)));
@@ -250,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

@@ -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

@@ -113,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)));
@@ -169,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());
         }

core/src/consensus/solo/mod.rs

@@ -78,7 +78,12 @@ impl ConsensusEngine for Solo<CodeChainMachine> {
         Seal::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 = *block.header().author();
         let (total_reward, total_min_fee) = {
             let transactions = block.transactions();
@@ -129,9 +134,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());
         }

core/src/consensus/stake/mod.rs

@@ -25,6 +25,7 @@ use std::sync::Arc;
 use ckey::Address;
 use cstate::{ActionHandler, StateResult, TopLevelState};
 use ctypes::errors::{RuntimeError, SyntaxError};
+use ctypes::{CommonParams, Header};
 use rlp::{Decodable, UntrustedRlp};
 
 use self::action_data::{Delegation, StakeAccount, Stakeholders};
@@ -118,7 +119,13 @@ impl ActionHandler for Stake {
         Ok(())
     }
 
-    fn on_close_block(&self, _state: &mut TopLevelState) -> StateResult<()> {
+    fn on_close_block(
+        &self,
+        _state: &mut TopLevelState,
+        _header: &Header,
+        _parent_header: &Header,
+        _parent_common_params: &CommonParams,
+    ) -> StateResult<()> {
         Ok(())
     }
 }

core/src/consensus/tendermint/engine.rs

@@ -128,7 +128,12 @@ impl ConsensusEngine for Tendermint {
 
     fn stop(&self) {}
 
-    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, total_min_fee) = {
             let transactions = block.transactions();

core/src/consensus/tendermint/mod.rs

@@ -151,7 +151,7 @@ mod tests {
         let genesis_header = scheme.genesis_header();
         let b = OpenBlock::try_new(scheme.engine.as_ref(), db, &genesis_header, proposer, vec![]).unwrap();
         let common_params = CommonParams::default_for_test();
-        let b = b.close(*genesis_header.transactions_root(), &common_params).unwrap();
+        let b = b.close(&genesis_header, &common_params).unwrap();
         if let Some(seal) = scheme.engine.generate_seal(b.block(), &genesis_header).seal_fields() {
             (b, seal)
         } else {