feat(consensus): Prevalidate blocks in reducers not enabling conditions

Also use error type for validation failure instead of boolean.

Author: tizoc

node/src/action_kind.rs

@@ -166,6 +166,8 @@ pub enum ActionKind {
     ConsensusBlockSnarkVerifyError,
     ConsensusBlockSnarkVerifyPending,
     ConsensusBlockSnarkVerifySuccess,
+    ConsensusBlockValidateError,
+    ConsensusBlockValidateSuccess,
     ConsensusDetectForkRange,
     ConsensusLongRangeForkResolve,
     ConsensusP2pBestTipUpdate,
@@ -716,7 +718,7 @@ pub enum ActionKind {
 }
 
 impl ActionKind {
-    pub const COUNT: u16 = 599;
+    pub const COUNT: u16 = 601;
 }
 
 impl std::fmt::Display for ActionKind {
@@ -857,6 +859,8 @@ impl ActionKindGet for ConsensusAction {
     fn kind(&self) -> ActionKind {
         match self {
             Self::BlockReceived { .. } => ActionKind::ConsensusBlockReceived,
+            Self::BlockValidateSuccess { .. } => ActionKind::ConsensusBlockValidateSuccess,
+            Self::BlockValidateError { .. } => ActionKind::ConsensusBlockValidateError,
             Self::BlockChainProofUpdate { .. } => ActionKind::ConsensusBlockChainProofUpdate,
             Self::BlockSnarkVerifyPending { .. } => ActionKind::ConsensusBlockSnarkVerifyPending,
             Self::BlockSnarkVerifySuccess { .. } => ActionKind::ConsensusBlockSnarkVerifySuccess,

node/src/consensus/consensus_actions.rs

@@ -9,6 +9,7 @@ use snark::block_verify::SnarkBlockVerifyError;
 
 use crate::consensus::ConsensusBlockStatus;
 use crate::snark::block_verify::SnarkBlockVerifyId;
+use crate::state::BlockValidationError;
 
 pub type ConsensusActionWithMeta = redux::ActionWithMeta<ConsensusAction>;
 pub type ConsensusActionWithMetaRef<'a> = redux::ActionWithMeta<&'a ConsensusAction>;
@@ -24,6 +25,13 @@ pub enum ConsensusAction {
         block: Arc<MinaBlockBlockStableV2>,
         chain_proof: Option<(Vec<StateHash>, ArcBlockWithHash)>,
     },
+    BlockValidateSuccess {
+        hash: StateHash,
+    },
+    BlockValidateError {
+        hash: StateHash,
+        error: BlockValidationError,
+    },
     BlockChainProofUpdate {
         hash: StateHash,
         chain_proof: (Vec<StateHash>, ArcBlockWithHash),
@@ -69,10 +77,14 @@ impl redux::EnablingCondition<crate::State> for ConsensusAction {
                     hash: hash.clone(),
                     block: block.clone()
                 };
-                !block.is_genesis()
-                    && !state.consensus.blocks.contains_key(hash)
-                    && state.prevalidate_block(&block)
+                !block.is_genesis() && !state.consensus.blocks.contains_key(hash)
             },
+            ConsensusAction::BlockValidateSuccess { hash }
+            | ConsensusAction::BlockValidateError { hash, .. } => state
+                .consensus
+                .blocks
+                .get(hash)
+                .map_or(false, |block| block.status.is_received()),
             ConsensusAction::BlockChainProofUpdate { hash, .. } => {
                 (state.consensus.best_tip.as_ref() == Some(hash)
                     && state.consensus.best_tip_chain_proof.is_none())
@@ -87,7 +99,7 @@ impl redux::EnablingCondition<crate::State> for ConsensusAction {
                     .consensus
                     .blocks
                     .get(hash)
-                    .map_or(false, |block| block.status.is_received())
+                    .map_or(false, |block| block.status.is_validated())
                     && state.snark.block_verify.jobs.contains(*req_id)
             },
             ConsensusAction::BlockSnarkVerifySuccess { hash } => {

node/src/consensus/consensus_reducer.rs

@@ -1,5 +1,5 @@
 use openmina_core::{
-    block::BlockHash,
+    block::{ArcBlockWithHash, BlockHash},
     bug_condition,
     consensus::{is_short_range_fork, long_range_fork_take, short_range_fork_take},
 };
@@ -48,9 +48,33 @@ impl ConsensusState {
                 );
 
                 // Dispatch
+                let (dispatcher, state) = state_context.into_dispatcher_and_state();
+
+                let hash = hash.clone();
+                let block = ArcBlockWithHash {
+                    hash: hash.clone(),
+                    block: block.clone(),
+                };
+                match state.prevalidate_block(&block) {
+                    Ok(()) => {
+                        dispatcher.push(ConsensusAction::BlockValidateSuccess { hash });
+                    }
+                    Err(error) => {
+                        dispatcher.push(ConsensusAction::BlockValidateError { hash, error });
+                    }
+                }
+            }
+            ConsensusAction::BlockValidateSuccess { hash } => {
+                let Some(block) = state.blocks.get_mut(hash) else {
+                    return;
+                };
+                block.status = ConsensusBlockStatus::Validated;
+
+                // Dispatch
+                let block = (hash.clone(), block.block.clone()).into();
                 let dispatcher = state_context.into_dispatcher();
                 dispatcher.push(SnarkBlockVerifyAction::Init {
-                    block: (hash.clone(), block.clone()).into(),
+                    block,
                     on_init: redux::callback!(
                         on_received_block_snark_verify_init((hash: BlockHash, req_id: SnarkBlockVerifyId)) -> crate::Action {
                             ConsensusAction::BlockSnarkVerifyPending { hash, req_id }
@@ -65,6 +89,9 @@ impl ConsensusState {
                         }),
                 });
             }
+            ConsensusAction::BlockValidateError { hash, .. } => {
+                state.blocks.remove(hash);
+            }
             ConsensusAction::BlockChainProofUpdate { hash, chain_proof } => {
                 if state.best_tip.as_ref() == Some(hash) {
                     state.best_tip_chain_proof = Some(chain_proof.clone());

node/src/consensus/consensus_state.rs

@@ -44,6 +44,7 @@ pub enum ConsensusBlockStatus {
     Received {
         time: redux::Timestamp,
     },
+    Validated,
     SnarkVerifyPending {
         time: redux::Timestamp,
         req_id: SnarkBlockVerifyId,
@@ -73,6 +74,10 @@ impl ConsensusBlockStatus {
         matches!(self, Self::Received { .. })
     }
 
+    pub fn is_validated(&self) -> bool {
+        matches!(self, Self::Validated)
+    }
+
     pub fn is_snark_verify_pending(&self) -> bool {
         matches!(self, Self::SnarkVerifyPending { .. })
     }
@@ -167,6 +172,7 @@ impl ConsensusState {
         };
         match &candidate.status {
             ConsensusBlockStatus::Received { .. } => false,
+            ConsensusBlockStatus::Validated => false,
             ConsensusBlockStatus::SnarkVerifyPending { .. } => false,
             ConsensusBlockStatus::SnarkVerifySuccess { .. } => false,
             ConsensusBlockStatus::ForkRangeDetected { .. } => false,

node/src/p2p/peer/p2p_peer_actions.rs

@@ -2,11 +2,6 @@ use super::*;
 
 impl redux::EnablingCondition<crate::State> for P2pPeerAction {
     fn is_enabled(&self, state: &crate::State, time: redux::Timestamp) -> bool {
-        if let P2pPeerAction::BestTipUpdate { best_tip, .. } = self {
-            if !state.prevalidate_block(best_tip) {
-                return false;
-            }
-        }
         state.p2p.is_enabled(self, time)
     }
 }

node/src/state.rs

@@ -73,6 +73,15 @@ pub struct State {
     applied_actions_count: u64,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum BlockValidationError {
+    GenesisNotReady,
+    TooEarly,
+    TooLate,
+    ConstantsMismatch,
+    GenesisMismatch,
+}
+
 // Substate accessors that will be used in reducers
 use openmina_core::{impl_substate_access, SubstateAccess};
 
@@ -356,15 +365,15 @@ impl State {
         })
     }
 
-    pub fn prevalidate_block(&self, block: &ArcBlockWithHash) -> bool {
+    pub fn prevalidate_block(&self, block: &ArcBlockWithHash) -> Result<(), BlockValidationError> {
         let Some((genesis, cur_global_slot)) =
             None.or_else(|| Some((self.genesis_block()?, self.cur_global_slot()?)))
         else {
             // we don't have genesis block. This should be impossible
             // because we don't even know chain_id before we have genesis
             // block, so we can't be connected to any peers from which
             // we would receive a block.
-            return false;
+            return Err(BlockValidationError::GenesisNotReady);
         };
 
         // received_at_valid_time
@@ -375,23 +384,23 @@ impl State {
             let delta = genesis.constants().delta.as_u32();
             if cur_global_slot < block_global_slot {
                 // Too_early
-                return false;
+                return Err(BlockValidationError::TooEarly);
             } else if cur_global_slot.saturating_sub(block_global_slot) > delta {
                 // Too_late
-                return false;
+                return Err(BlockValidationError::TooLate);
             }
         }
 
         if block.constants() != genesis.constants() {
-            return false;
+            return Err(BlockValidationError::ConstantsMismatch);
         }
 
         if block.header().genesis_state_hash() != genesis.hash() {
-            return false;
+            return Err(BlockValidationError::GenesisMismatch);
         }
 
         // TODO(binier): more checks.
-        true
+        Ok(())
     }
 
     pub fn should_log_node_id(&self) -> bool {