refactor(consensus): Combine all action types of the consensus module into the parent action type

Author: tizoc

node/src/consensus/consensus_actions.rs

@@ -10,188 +10,121 @@ use crate::snark::block_verify::SnarkBlockVerifyId;
 pub type ConsensusActionWithMeta = redux::ActionWithMeta<ConsensusAction>;
 pub type ConsensusActionWithMetaRef<'a> = redux::ActionWithMeta<&'a ConsensusAction>;
 
-#[derive(derive_more::From, Serialize, Deserialize, Debug, Clone)]
-pub enum ConsensusAction {
-    BlockReceived(ConsensusBlockReceivedAction),
-    BlockChainProofUpdate(ConsensusBlockChainProofUpdateAction),
-    BlockSnarkVerifyPending(ConsensusBlockSnarkVerifyPendingAction),
-    BlockSnarkVerifySuccess(ConsensusBlockSnarkVerifySuccessAction),
-    DetectForkRange(ConsensusDetectForkRangeAction),
-    ShortRangeForkResolve(ConsensusShortRangeForkResolveAction),
-    LongRangeForkResolve(ConsensusLongRangeForkResolveAction),
-    BestTipUpdate(ConsensusBestTipUpdateAction),
-    Prune(ConsensusPruneAction),
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ConsensusBlockReceivedAction {
-    pub hash: StateHash,
-    pub block: Arc<MinaBlockBlockStableV2>,
-    pub chain_proof: Option<(Vec<StateHash>, ArcBlockWithHash)>,
-}
-
-impl redux::EnablingCondition<crate::State> for ConsensusBlockReceivedAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        !state.consensus.blocks.contains_key(&self.hash)
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ConsensusBlockChainProofUpdateAction {
-    pub hash: StateHash,
-    pub chain_proof: (Vec<StateHash>, ArcBlockWithHash),
-}
-
-impl redux::EnablingCondition<crate::State> for ConsensusBlockChainProofUpdateAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        (state.consensus.best_tip.as_ref() == Some(&self.hash)
-            && state.consensus.best_tip_chain_proof.is_none())
-            || state
-                .consensus
-                .blocks
-                .get(&self.hash)
-                .map_or(false, |b| b.status.is_pending() && b.chain_proof.is_none())
-    }
-}
-
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ConsensusBlockSnarkVerifyPendingAction {
-    pub req_id: SnarkBlockVerifyId,
-    pub hash: StateHash,
-}
-
-impl redux::EnablingCondition<crate::State> for ConsensusBlockSnarkVerifyPendingAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        state
-            .consensus
-            .blocks
-            .get(&self.hash)
-            .map_or(false, |block| block.status.is_received())
-            && state.snark.block_verify.jobs.contains(self.req_id)
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ConsensusBlockSnarkVerifySuccessAction {
-    pub hash: StateHash,
-}
-
-impl redux::EnablingCondition<crate::State> for ConsensusBlockSnarkVerifySuccessAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        state
-            .consensus
-            .blocks
-            .get(&self.hash)
-            .map_or(false, |block| block.status.is_snark_verify_pending())
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ConsensusDetectForkRangeAction {
-    pub hash: StateHash,
-}
-
-impl redux::EnablingCondition<crate::State> for ConsensusDetectForkRangeAction {
-    fn is_enabled(&self, #[allow(unused_variables)] state: &crate::State) -> bool {
-        state
-            .consensus
-            .blocks
-            .get(&self.hash)
-            .map_or(false, |block| {
-                matches!(
-                    block.status,
-                    ConsensusBlockStatus::SnarkVerifySuccess { .. }
-                )
-            })
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ConsensusShortRangeForkResolveAction {
-    pub hash: StateHash,
-}
-
-impl redux::EnablingCondition<crate::State> for ConsensusShortRangeForkResolveAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        state
-            .consensus
-            .blocks
-            .get(&self.hash)
-            .map_or(false, |block| match state.consensus.best_tip() {
-                Some(tip) => {
-                    matches!(
-                        &block.status,
-                        ConsensusBlockStatus::ForkRangeDetected { compared_with, short_fork, .. }
-                            if compared_with.as_ref() == Some(tip.hash) && *short_fork
-                    )
-                }
-                None => true,
-            })
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ConsensusLongRangeForkResolveAction {
-    pub hash: StateHash,
-}
-
-impl redux::EnablingCondition<crate::State> for ConsensusLongRangeForkResolveAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        state
-            .consensus
-            .blocks
-            .get(&self.hash)
-            .map_or(false, |block| match state.consensus.best_tip() {
-                Some(tip) => {
-                    matches!(
-                        &block.status,
-                        ConsensusBlockStatus::ForkRangeDetected { compared_with, short_fork, .. }
-                             if compared_with.as_ref() == Some(tip.hash) && !*short_fork
-                    )
-                }
-                None => false,
-            })
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ConsensusBestTipUpdateAction {
-    pub hash: StateHash,
-}
-
-impl redux::EnablingCondition<crate::State> for ConsensusBestTipUpdateAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        state
-            .consensus
-            .is_candidate_decided_to_use_as_tip(&self.hash)
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ConsensusPruneAction {}
-
-impl redux::EnablingCondition<crate::State> for ConsensusPruneAction {
+pub enum ConsensusAction {
+    BlockReceived {
+        hash: StateHash,
+        block: Arc<MinaBlockBlockStableV2>,
+        chain_proof: Option<(Vec<StateHash>, ArcBlockWithHash)>,
+    },
+    BlockChainProofUpdate {
+        hash: StateHash,
+        chain_proof: (Vec<StateHash>, ArcBlockWithHash),
+    },
+    BlockSnarkVerifyPending {
+        req_id: SnarkBlockVerifyId,
+        hash: StateHash,
+    },
+    BlockSnarkVerifySuccess {
+        hash: StateHash,
+    },
+    DetectForkRange {
+        hash: StateHash,
+    },
+    ShortRangeForkResolve {
+        hash: StateHash,
+    },
+    LongRangeForkResolve {
+        hash: StateHash,
+    },
+    BestTipUpdate {
+        hash: StateHash,
+    },
+    Prune,
+}
+
+impl redux::EnablingCondition<crate::State> for ConsensusAction {
     fn is_enabled(&self, state: &crate::State) -> bool {
-        state.consensus.best_tip().is_some()
-    }
-}
-
-macro_rules! impl_into_global_action {
-    ($a:ty) => {
-        impl From<$a> for crate::Action {
-            fn from(value: $a) -> Self {
-                Self::Consensus(value.into())
-            }
+        match self {
+            ConsensusAction::BlockReceived { hash, .. } => {
+                !state.consensus.blocks.contains_key(hash)
+            },
+            ConsensusAction::BlockChainProofUpdate { hash, .. } => {
+                (state.consensus.best_tip.as_ref() == Some(hash)
+                    && state.consensus.best_tip_chain_proof.is_none())
+                    || state
+                        .consensus
+                        .blocks
+                        .get(hash)
+                        .map_or(false, |b| b.status.is_pending() && b.chain_proof.is_none())
+            },
+            ConsensusAction::BlockSnarkVerifyPending { req_id, hash } => {
+                state
+                    .consensus
+                    .blocks
+                    .get(hash)
+                    .map_or(false, |block| block.status.is_received())
+                    && state.snark.block_verify.jobs.contains(*req_id)
+            },
+            ConsensusAction::BlockSnarkVerifySuccess { hash } => {
+                state
+                    .consensus
+                    .blocks
+                    .get(hash)
+                    .map_or(false, |block| block.status.is_snark_verify_pending())
+            },
+            ConsensusAction::DetectForkRange { hash } => {
+                state
+                    .consensus
+                    .blocks
+                    .get(hash)
+                    .map_or(false, |block| {
+                        matches!(
+                            block.status,
+                            ConsensusBlockStatus::SnarkVerifySuccess { .. }
+                        )
+                    })
+            },
+            ConsensusAction::ShortRangeForkResolve { hash } => {
+                state
+                    .consensus
+                    .blocks
+                    .get(hash)
+                    .map_or(false, |block| match state.consensus.best_tip() {
+                        Some(tip) => {
+                            matches!(
+                                &block.status,
+                                ConsensusBlockStatus::ForkRangeDetected { compared_with, short_fork, .. }
+                                    if compared_with.as_ref() == Some(tip.hash) && *short_fork
+                            )
+                        }
+                        None => true,
+                    })
+            },
+            ConsensusAction::LongRangeForkResolve { hash } => {
+                state
+                    .consensus
+                    .blocks
+                    .get(hash)
+                    .map_or(false, |block| match state.consensus.best_tip() {
+                        Some(tip) => {
+                            matches!(
+                                &block.status,
+                                ConsensusBlockStatus::ForkRangeDetected { compared_with, short_fork, .. }
+                                     if compared_with.as_ref() == Some(tip.hash) && !*short_fork
+                            )
+                        }
+                        None => false,
+                    })
+            },
+            ConsensusAction::BestTipUpdate { hash } => {
+                state
+                    .consensus
+                    .is_candidate_decided_to_use_as_tip(hash)
+            },
+            ConsensusAction::Prune => {
+                state.consensus.best_tip().is_some()
+            },
         }
-    };
+    }
 }
-
-impl_into_global_action!(ConsensusBlockReceivedAction);
-impl_into_global_action!(ConsensusBlockChainProofUpdateAction);
-impl_into_global_action!(ConsensusBlockSnarkVerifyPendingAction);
-impl_into_global_action!(ConsensusBlockSnarkVerifySuccessAction);
-impl_into_global_action!(ConsensusDetectForkRangeAction);
-impl_into_global_action!(ConsensusShortRangeForkResolveAction);
-impl_into_global_action!(ConsensusLongRangeForkResolveAction);
-impl_into_global_action!(ConsensusBestTipUpdateAction);
-impl_into_global_action!(ConsensusPruneAction);

node/src/consensus/consensus_effects.rs

@@ -8,49 +8,40 @@ use crate::{
     watched_accounts::WatchedAccountsBlockTransactionsIncludedAction,
 };
 
-use super::{
-    ConsensusAction, ConsensusActionWithMeta, ConsensusBestTipUpdateAction,
-    ConsensusBlockSnarkVerifyPendingAction, ConsensusDetectForkRangeAction,
-    ConsensusLongRangeForkResolveAction, ConsensusShortRangeForkResolveAction,
-};
+use super::{ConsensusAction, ConsensusActionWithMeta};
 
 pub fn consensus_effects<S: crate::Service>(store: &mut Store<S>, action: ConsensusActionWithMeta) {
     let (action, _) = action.split();
 
     match action {
-        ConsensusAction::BlockReceived(action) => {
+        ConsensusAction::BlockReceived { hash, block, .. } => {
             let req_id = store.state().snark.block_verify.next_req_id();
             store.dispatch(SnarkBlockVerifyInitAction {
                 req_id,
-                block: (action.hash.clone(), action.block).into(),
-            });
-            store.dispatch(ConsensusBlockSnarkVerifyPendingAction {
-                req_id,
-                hash: action.hash,
+                block: (hash.clone(), block).into(),
             });
+            store.dispatch(ConsensusAction::BlockSnarkVerifyPending { req_id, hash });
         }
-        ConsensusAction::BlockChainProofUpdate(a) => {
-            if store.state().consensus.best_tip.as_ref() == Some(&a.hash) {
+        ConsensusAction::BlockChainProofUpdate { hash, .. } => {
+            if store.state().consensus.best_tip.as_ref() == Some(&hash) {
                 transition_frontier_new_best_tip(store);
             }
         }
-        ConsensusAction::BlockSnarkVerifyPending(_) => {}
-        ConsensusAction::BlockSnarkVerifySuccess(a) => {
-            store.dispatch(ConsensusDetectForkRangeAction { hash: a.hash });
+        ConsensusAction::BlockSnarkVerifyPending { .. } => {}
+        ConsensusAction::BlockSnarkVerifySuccess { hash } => {
+            store.dispatch(ConsensusAction::DetectForkRange { hash });
         }
-        ConsensusAction::DetectForkRange(a) => {
-            store.dispatch(ConsensusShortRangeForkResolveAction {
-                hash: a.hash.clone(),
-            });
-            store.dispatch(ConsensusLongRangeForkResolveAction { hash: a.hash });
+        ConsensusAction::DetectForkRange { hash } => {
+            store.dispatch(ConsensusAction::ShortRangeForkResolve { hash: hash.clone() });
+            store.dispatch(ConsensusAction::LongRangeForkResolve { hash });
         }
-        ConsensusAction::ShortRangeForkResolve(a) => {
-            store.dispatch(ConsensusBestTipUpdateAction { hash: a.hash });
+        ConsensusAction::ShortRangeForkResolve { hash } => {
+            store.dispatch(ConsensusAction::BestTipUpdate { hash });
         }
-        ConsensusAction::LongRangeForkResolve(a) => {
-            store.dispatch(ConsensusBestTipUpdateAction { hash: a.hash });
+        ConsensusAction::LongRangeForkResolve { hash } => {
+            store.dispatch(ConsensusAction::BestTipUpdate { hash });
         }
-        ConsensusAction::BestTipUpdate(_) => {
+        ConsensusAction::BestTipUpdate { .. } => {
             let Some(block) = store.state.get().consensus.best_tip_block_with_hash() else {
                 return;
             };
@@ -66,7 +57,7 @@ pub fn consensus_effects<S: crate::Service>(store: &mut Store<S>, action: Consen
 
             transition_frontier_new_best_tip(store);
         }
-        ConsensusAction::Prune(_) => {}
+        ConsensusAction::Prune => {}
     }
 }