Add a close block event handler to ActionHandler

Author: Seulgi Kim

core/src/block.rs

@@ -227,6 +227,13 @@ impl<'x> OpenBlock<'x> {
             warn!("Encountered error on closing the block: {}", e);
             return Err(e)
         }
+        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
+            })?;
+        }
+
         let state_root = self.block.state.commit().map_err(|e| {
             warn!("Encountered error on state commit: {}", e);
             e
@@ -253,6 +260,12 @@ impl<'x> OpenBlock<'x> {
             warn!("Encountered error on closing the block: {}", e);
             return Err(e)
         }
+        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
+            })?;
+        }
 
         let state_root = self.block.state.commit().map_err(|e| {
             warn!("Encountered error on state commit: {}", e);

core/src/consensus/stake/mod.rs

@@ -71,6 +71,10 @@ fn parse_env_var_enable_delegations() -> bool {
 }
 
 impl ActionHandler for Stake {
+    fn name(&self) -> &'static str {
+        "stake handler"
+    }
+
     fn handler_id(&self) -> u64 {
         CUSTOM_ACTION_HANDLER_ID
     }
@@ -113,6 +117,10 @@ impl ActionHandler for Stake {
         Action::decode(&UntrustedRlp::new(bytes)).map_err(|err| SyntaxError::InvalidCustomAction(err.to_string()))?;
         Ok(())
     }
+
+    fn on_close_block(&self, _state: &mut TopLevelState) -> StateResult<()> {
+        Ok(())
+    }
 }
 
 fn transfer_ccs(state: &mut TopLevelState, sender: &Address, receiver: &Address, quantity: u64) -> StateResult<()> {

state/src/action_handler/hit.rs

@@ -37,30 +37,40 @@ impl HitHandler {
         Self::default()
     }
 
-    fn address(&self) -> H256 {
-        ActionDataKeyBuilder::new(CUSTOM_ACTION_HANDLER_ID, 1).append(&"metadata hit").into_key()
+    fn hit_count(&self) -> H256 {
+        ActionDataKeyBuilder::new(CUSTOM_ACTION_HANDLER_ID, 1).append(&"hit count").into_key()
+    }
+
+    fn close_count(&self) -> H256 {
+        ActionDataKeyBuilder::new(CUSTOM_ACTION_HANDLER_ID, 1).append(&"close count").into_key()
     }
 }
 
 impl ActionHandler for HitHandler {
+    fn name(&self) -> &'static str {
+        "hit handler"
+    }
+
     fn handler_id(&self) -> u64 {
         CUSTOM_ACTION_HANDLER_ID
     }
 
     fn init(&self, state: &mut TopLevelState) -> StateResult<()> {
-        let existing = state.action_data(&self.address());
+        let existing = state.action_data(&self.hit_count());
         debug_assert_eq!(Ok(None), existing);
-        state.update_action_data(&self.address(), 1u32.rlp_bytes().to_vec())?;
+        state.update_action_data(&self.hit_count(), 1u32.rlp_bytes().to_vec())?;
+        state.update_action_data(&self.close_count(), 1u32.rlp_bytes().to_vec())?;
         Ok(())
     }
 
     /// `bytes` must be valid encoding of HitAction
     fn execute(&self, bytes: &[u8], state: &mut TopLevelState, _sender: &Address) -> StateResult<()> {
+        let address = self.hit_count();
         let action = HitAction::decode(&UntrustedRlp::new(bytes)).expect("Verification passed");
-        let action_data = state.action_data(&self.address())?.unwrap_or_default();
+        let action_data = state.action_data(&address)?.unwrap_or_default();
         let prev_counter: u32 = rlp::decode(&*action_data);
         let increase = u32::from(action.increase);
-        state.update_action_data(&self.address(), (prev_counter + increase).rlp_bytes().to_vec())?;
+        state.update_action_data(&address, (prev_counter + increase).rlp_bytes().to_vec())?;
         Ok(())
     }
 
@@ -69,4 +79,12 @@ impl ActionHandler for HitHandler {
             .map_err(|err| SyntaxError::InvalidCustomAction(err.to_string()))?;
         Ok(())
     }
+
+    fn on_close_block(&self, state: &mut TopLevelState) -> StateResult<()> {
+        let address = self.close_count();
+        let action_data = state.action_data(&address)?.unwrap_or_default();
+        let prev_counter: u32 = rlp::decode(&*action_data);
+        state.update_action_data(&address, (prev_counter + 1).rlp_bytes().to_vec())?;
+        Ok(())
+    }
 }

state/src/action_handler/mod.rs

@@ -28,6 +28,7 @@ use super::TopStateView;
 use crate::{StateResult, TopLevelState};
 
 pub trait ActionHandler: Send + Sync {
+    fn name(&self) -> &'static str;
     fn handler_id(&self) -> u64;
     fn init(&self, state: &mut TopLevelState) -> StateResult<()>;
     fn execute(&self, bytes: &[u8], state: &mut TopLevelState, sender: &Address) -> StateResult<()>;
@@ -38,6 +39,8 @@ pub trait ActionHandler: Send + Sync {
         let some_action_data = state.action_data(&key)?.map(Vec::from);
         Ok(some_action_data)
     }
+
+    fn on_close_block(&self, state: &mut TopLevelState) -> StateResult<()>;
 }
 
 pub trait FindActionHandler {

test/src/e2e/customAction.test.ts

@@ -45,18 +45,37 @@ describe("customAction", function() {
         it("should get initial state", async function() {
             const actionData = await node.sdk.rpc.engine.getCustomActionData(
                 hitActionHandlerId,
-                ["metadata hit"]
+                ["hit count"]
             );
 
             expect(actionData).to.be.equal(toHex(RLP.encode(1)));
         });
 
         it("should alter state", async function() {
+            const previousHitData = (await node.sdk.rpc.engine.getCustomActionData(
+                hitActionHandlerId,
+                ["hit count"]
+            ))!;
+            const previousHitCount = Buffer.from(
+                previousHitData,
+                "hex"
+            ).readUInt8(0);
+
+            const previousBlockCloseData = (await node.sdk.rpc.engine.getCustomActionData(
+                hitActionHandlerId,
+                ["close count"]
+            ))!;
+            const previousBlockCloseCount = Buffer.from(
+                previousBlockCloseData,
+                "hex"
+            ).readUInt8(0);
+
+            const increment = 11;
             const hash = await node.sdk.rpc.chain.sendSignedTransaction(
                 node.sdk.core
                     .createCustomTransaction({
                         handlerId: hitActionHandlerId,
-                        bytes: RLP.encode([11])
+                        bytes: RLP.encode([increment])
                     })
                     .sign({
                         secret: faucetSecret,
@@ -68,12 +87,21 @@ describe("customAction", function() {
             expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
             expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
 
-            const actionData = await node.sdk.rpc.engine.getCustomActionData(
+            const hitData = await node.sdk.rpc.engine.getCustomActionData(
                 hitActionHandlerId,
-                ["metadata hit"]
+                ["hit count"]
             );
 
-            expect(actionData).to.be.equal(toHex(RLP.encode(12)));
+            expect(hitData).to.be.equal(
+                toHex(RLP.encode(previousHitCount + increment))
+            );
+            const closeData = await node.sdk.rpc.engine.getCustomActionData(
+                hitActionHandlerId,
+                ["close count"]
+            );
+            expect(closeData).to.be.equal(
+                toHex(RLP.encode(previousBlockCloseCount + 1))
+            );
         });
 
         it("should return null", async function() {
@@ -89,7 +117,7 @@ describe("customAction", function() {
             try {
                 await node.sdk.rpc.engine.getCustomActionData(
                     hitActionHandlerId,
-                    ["metadata hit"],
+                    ["hit count"],
                     99999
                 );
                 fail();