Merge pull request #3316 from Conflux-Chain/pos_reward

fix: check if the pos reward in DB is on pivot for reexecution.

Author: Pana

crates/cfxcore/core/src/block_data_manager/mod.rs

@@ -1344,6 +1344,39 @@ impl BlockDataManager {
         }
         let me_height = self.block_height_by_hash(epoch_hash).unwrap();
         if pos_verifier.pos_option().is_some() && me_height != 0 {
+            // Check if stored pos reward is on pivot.
+            let pivot_block_header = self
+                .block_header_by_hash(epoch_hash)
+                .expect("header exists");
+            let maybe_parent_pos_ref = self
+                .block_header_by_hash(&pivot_block_header.parent_hash()) // `None` only for genesis.
+                .and_then(|parent| parent.pos_reference().clone());
+            if pos_verifier.is_enabled_at_height(me_height)
+                && maybe_parent_pos_ref.is_some()
+                && maybe_parent_pos_ref != *pivot_block_header.pos_reference()
+            {
+                if let Some((pos_epoch, _)) = pos_verifier
+                    .get_reward_distribution_event(
+                        pivot_block_header.pos_reference().as_ref().unwrap(),
+                        maybe_parent_pos_ref.as_ref().unwrap(),
+                    )
+                    .as_ref()
+                    .and_then(|x| x.first())
+                {
+                    if let Some(pos_reward) =
+                        self.pos_reward_by_pos_epoch(*pos_epoch)
+                    {
+                        if pos_reward.execution_epoch_hash != *epoch_hash {
+                            // The stored pos reward is executed in another
+                            // epoch, so we need to
+                            // reexecute this epoch to restore the pos reward of
+                            // the current pivot.
+                            return false;
+                        }
+                    }
+                }
+            }
+
             trace!(
                 "staking events update: height={}, new={}",
                 me_height,

crates/cfxcore/core/src/consensus/consensus_inner/consensus_executor/mod.rs

@@ -1014,6 +1014,8 @@ impl ConsensusExecutionHandler {
             self.data_man
                 .insert_hash_by_block_number(block_number, hash);
         }
+        let end_block_number =
+            start_block_number + epoch_block_hashes.len() as u64 - 1;
 
         let pivot_block_header = self
             .data_man
@@ -1071,13 +1073,10 @@ impl ConsensusExecutionHandler {
             // program may restart by itself.
             .expect("Can not handle db error in consensus, crashing.");
 
-        let current_block_number =
-            start_block_number + epoch_receipts.len() as u64 - 1;
-
         if let Some(reward_execution_info) = reward_execution_info {
             let spec = self
                 .machine
-                .spec(current_block_number, pivot_block.block_header.height());
+                .spec(end_block_number, pivot_block.block_header.height());
             // Calculate the block reward for blocks inside the epoch
             // All transaction fees are shared among blocks inside one epoch
             self.process_rewards_and_fees(
@@ -1092,8 +1091,8 @@ impl ConsensusExecutionHandler {
 
         self.process_pos_interest(
             &mut state,
-            pivot_block,
-            current_block_number,
+            &pivot_block.block_header,
+            end_block_number,
         )
         .expect("db error");
 
@@ -1162,23 +1161,22 @@ impl ConsensusExecutionHandler {
     }
 
     fn process_pos_interest(
-        &self, state: &mut State, pivot_block: &Block,
+        &self, state: &mut State, pivot_header: &BlockHeader,
         current_block_number: u64,
     ) -> DbResult<()> {
         // TODO(peilun): Specify if we unlock before or after executing the
         // transactions.
         let maybe_parent_pos_ref = self
             .data_man
-            .block_header_by_hash(&pivot_block.block_header.parent_hash()) // `None` only for genesis.
+            .block_header_by_hash(&pivot_header.parent_hash()) // `None` only for genesis.
             .and_then(|parent| parent.pos_reference().clone());
         if self
             .pos_verifier
-            .is_enabled_at_height(pivot_block.block_header.height())
+            .is_enabled_at_height(pivot_header.height())
             && maybe_parent_pos_ref.is_some()
-            && *pivot_block.block_header.pos_reference() != maybe_parent_pos_ref
+            && *pivot_header.pos_reference() != maybe_parent_pos_ref
         {
-            let current_pos_ref = pivot_block
-                .block_header
+            let current_pos_ref = pivot_header
                 .pos_reference()
                 .as_ref()
                 .expect("checked before sync graph insertion");
@@ -1208,7 +1206,7 @@ impl ConsensusExecutionHandler {
                     )?;
                 self.data_man.insert_pos_reward(
                     *pos_epoch,
-                    &PosRewardInfo::new(account_rewards, pivot_block.hash()),
+                    &PosRewardInfo::new(account_rewards, pivot_header.hash()),
                 )
             }
         }