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

tizoc · tizoc · commit 2bf5ca33466a · 2024-02-01T15:20:00.000-03:00
diff --git a/node/src/event_source/event_source_effects.rs b/node/src/event_source/event_source_effects.rs
@@ -46,7 +46,7 @@ use crate::rpc::{
     RpcSyncStatsGetAction,
 };
 use crate::snark::block_verify::SnarkBlockVerifyAction;
-use crate::snark::work_verify::{SnarkWorkVerifyErrorAction, SnarkWorkVerifySuccessAction};
+use crate::snark::work_verify::SnarkWorkVerifyAction;
 use crate::snark::SnarkEvent;
 use crate::{Service, Store};
 
@@ -245,10 +245,10 @@ pub fn event_source_effects<S: Service>(store: &mut Store<S>, action: EventSourc
                 },
                 SnarkEvent::WorkVerify(req_id, result) => match result {
                     Err(error) => {
-                        store.dispatch(SnarkWorkVerifyErrorAction { req_id, error });
+                        store.dispatch(SnarkWorkVerifyAction::Error { req_id, error });
                     }
                     Ok(()) => {
-                        store.dispatch(SnarkWorkVerifySuccessAction { req_id });
+                        store.dispatch(SnarkWorkVerifyAction::Success { req_id });
                     }
                 },
             },
diff --git a/node/src/logger/logger_effects.rs b/node/src/logger/logger_effects.rs
@@ -525,39 +525,43 @@ pub fn logger_effects<S: Service>(store: &Store<S>, action: ActionWithMetaRef<'_
         }
         Action::Snark(a) => match a {
             SnarkAction::WorkVerify(a) => match a {
-                SnarkWorkVerifyAction::Init(a) => {
+                SnarkWorkVerifyAction::Init {
+                    req_id,
+                    batch,
+                    sender,
+                } => {
                     openmina_core::log::info!(
                         meta.time();
                         kind = kind.to_string(),
-                        summary = format!("id: {}, batch size: {}", a.req_id, a.batch.len()),
-                        peer_id = a.sender,
-                        rpc_id = a.req_id.to_string(),
-                        trace_batch = serde_json::to_string(&a.batch.iter().map(|v| v.job_id()).collect::<Vec<_>>()).ok()
+                        summary = format!("id: {}, batch size: {}", req_id, batch.len()),
+                        peer_id = sender,
+                        rpc_id = req_id.to_string(),
+                        trace_batch = serde_json::to_string(&batch.iter().map(|v| v.job_id()).collect::<Vec<_>>()).ok()
                     );
                 }
-                SnarkWorkVerifyAction::Error(a) => {
-                    let Some(req) = store.state().snark.work_verify.jobs.get(a.req_id) else {
+                SnarkWorkVerifyAction::Error { req_id, .. } => {
+                    let Some(req) = store.state().snark.work_verify.jobs.get(*req_id) else {
                         return;
                     };
                     openmina_core::log::warn!(
                         meta.time();
                         kind = kind.to_string(),
-                        summary = format!("id: {}, batch size: {}", a.req_id, req.batch().len()),
+                        summary = format!("id: {}, batch size: {}", req_id, req.batch().len()),
                         peer_id = req.sender(),
-                        rpc_id = a.req_id.to_string(),
+                        rpc_id = req_id.to_string(),
                         trace_batch = serde_json::to_string(&req.batch().iter().map(|v| v.job_id()).collect::<Vec<_>>()).ok()
                     );
                 }
-                SnarkWorkVerifyAction::Success(a) => {
-                    let Some(req) = store.state().snark.work_verify.jobs.get(a.req_id) else {
+                SnarkWorkVerifyAction::Success { req_id } => {
+                    let Some(req) = store.state().snark.work_verify.jobs.get(*req_id) else {
                         return;
                     };
                     openmina_core::log::info!(
                         meta.time();
                         kind = kind.to_string(),
-                        summary = format!("id: {}, batch size: {}", a.req_id, req.batch().len()),
+                        summary = format!("id: {}, batch size: {}", req_id, req.batch().len()),
                         peer_id = req.sender(),
-                        rpc_id = a.req_id.to_string(),
+                        rpc_id = req_id.to_string(),
                         trace_batch = serde_json::to_string(&req.batch().iter().map(|v| v.job_id()).collect::<Vec<_>>()).ok()
                     );
                 }
diff --git a/node/src/snark/snark_effects.rs b/node/src/snark/snark_effects.rs
@@ -12,47 +12,52 @@ pub fn snark_effects<S: Service>(store: &mut Store<S>, action: SnarkActionWithMe
 
     match action {
         SnarkAction::BlockVerify(a) => {
-            if let SnarkBlockVerifyAction::Success { req_id } = a {
-                let req = store.state().snark.block_verify.jobs.get(req_id);
-                let Some(req) = req else { return };
-                store.dispatch(ConsensusAction::BlockSnarkVerifySuccess {
-                    hash: req.block().hash_ref().clone(),
-                });
+            match a {
+                SnarkBlockVerifyAction::Success { req_id } => {
+                    let req = store.state().snark.block_verify.jobs.get(req_id);
+                    let Some(req) = req else { return };
+                    store.dispatch(ConsensusAction::BlockSnarkVerifySuccess {
+                        hash: req.block().hash_ref().clone(),
+                    });
+                }
+                SnarkBlockVerifyAction::Init { .. } => {}
+                SnarkBlockVerifyAction::Pending { .. } => {}
+                SnarkBlockVerifyAction::Error { .. } => {}
+                SnarkBlockVerifyAction::Finish { .. } => {}
             }
             a.effects(&meta, store);
         }
-        SnarkAction::WorkVerify(a) => match a {
-            SnarkWorkVerifyAction::Init(a) => {
-                a.effects(&meta, store);
-            }
-            SnarkWorkVerifyAction::Pending(_) => {}
-            SnarkWorkVerifyAction::Error(a) => {
-                let req = store.state().snark.work_verify.jobs.get(a.req_id);
-                let Some(req) = req else { return };
-                let sender = req.sender().parse().unwrap();
+        SnarkAction::WorkVerify(a) => {
+            match a {
+                SnarkWorkVerifyAction::Error { req_id, .. } => {
+                    let req = store.state().snark.work_verify.jobs.get(req_id);
+                    let Some(req) = req else { return };
+                    let sender = req.sender().parse().unwrap();
 
-                store.dispatch(SnarkPoolCandidateAction::WorkVerifyError {
-                    peer_id: sender,
-                    verify_id: a.req_id,
-                });
-                a.effects(&meta, store);
-            }
-            SnarkWorkVerifyAction::Success(a) => {
-                let req = store.state().snark.work_verify.jobs.get(a.req_id);
-                let Some(req) = req else { return };
-                let sender = req.sender().parse().unwrap();
-                let batch = req.batch().to_vec();
+                    store.dispatch(SnarkPoolCandidateAction::WorkVerifyError {
+                        peer_id: sender,
+                        verify_id: req_id,
+                    });
+                }
+                SnarkWorkVerifyAction::Success { req_id } => {
+                    let req = store.state().snark.work_verify.jobs.get(req_id);
+                    let Some(req) = req else { return };
+                    let sender = req.sender().parse().unwrap();
+                    let batch = req.batch().to_vec();
 
-                store.dispatch(SnarkPoolCandidateAction::WorkVerifySuccess {
-                    peer_id: sender,
-                    verify_id: a.req_id,
-                });
-                for snark in batch {
-                    store.dispatch(SnarkPoolWorkAddAction { snark, sender });
+                    store.dispatch(SnarkPoolCandidateAction::WorkVerifySuccess {
+                        peer_id: sender,
+                        verify_id: req_id,
+                    });
+                    for snark in batch {
+                        store.dispatch(SnarkPoolWorkAddAction { snark, sender });
+                    }
                 }
-                a.effects(&meta, store);
+                SnarkWorkVerifyAction::Init { .. } => {}
+                SnarkWorkVerifyAction::Pending { .. } => {}
+                SnarkWorkVerifyAction::Finish { .. } => {}
             }
-            SnarkWorkVerifyAction::Finish(_) => {}
-        },
+            a.effects(&meta, store);
+        }
     }
 }
diff --git a/node/src/snark/work_verify/snark_work_verify_actions.rs b/node/src/snark/work_verify/snark_work_verify_actions.rs
@@ -1,49 +1,13 @@
 use super::*;
 
-impl redux::EnablingCondition<crate::State> for SnarkWorkVerifyInitAction {
+impl redux::EnablingCondition<crate::State> for SnarkWorkVerifyAction {
     fn is_enabled(&self, state: &crate::State) -> bool {
         self.is_enabled(&state.snark)
     }
 }
 
-impl redux::EnablingCondition<crate::State> for SnarkWorkVerifyPendingAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        self.is_enabled(&state.snark)
-    }
-}
-
-impl redux::EnablingCondition<crate::State> for SnarkWorkVerifyErrorAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        self.is_enabled(&state.snark)
-    }
-}
-
-impl redux::EnablingCondition<crate::State> for SnarkWorkVerifySuccessAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        self.is_enabled(&state.snark)
-    }
-}
-
-impl redux::EnablingCondition<crate::State> for SnarkWorkVerifyFinishAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        self.is_enabled(&state.snark)
-    }
-}
-
-impl From<SnarkWorkVerifyInitAction> for crate::Action {
-    fn from(a: SnarkWorkVerifyInitAction) -> Self {
-        Self::Snark(a.into())
-    }
-}
-
-impl From<SnarkWorkVerifyErrorAction> for crate::Action {
-    fn from(a: SnarkWorkVerifyErrorAction) -> Self {
-        Self::Snark(a.into())
-    }
-}
-
-impl From<SnarkWorkVerifySuccessAction> for crate::Action {
-    fn from(a: SnarkWorkVerifySuccessAction) -> Self {
-        Self::Snark(a.into())
+impl From<SnarkWorkVerifyAction> for crate::Action {
+    fn from(value: SnarkWorkVerifyAction) -> Self {
+        Self::Snark(value.into())
     }
 }
diff --git a/node/src/snark_pool/candidate/snark_pool_candidate_effects.rs b/node/src/snark_pool/candidate/snark_pool_candidate_effects.rs
@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use snark::work_verify::SnarkWorkVerifyInitAction;
+use snark::work_verify::SnarkWorkVerifyAction;
 
 use crate::p2p::channels::rpc::{P2pChannelsRpcRequestSendAction, P2pRpcRequest};
 use crate::p2p::disconnection::{P2pDisconnectionInitAction, P2pDisconnectionReason};
@@ -71,7 +71,7 @@ pub fn snark_pool_candidate_effects<S: redux::Service>(
             let req_id = state.snark.work_verify.next_req_id();
             let job_ids = batch.iter().map(|v| v.job_id()).collect::<Vec<_>>();
             let sender = peer_id.to_string();
-            store.dispatch(SnarkWorkVerifyInitAction {
+            store.dispatch(SnarkWorkVerifyAction::Init {
                 req_id,
                 batch,
                 sender,
diff --git a/snark/src/work_verify/snark_work_verify_actions.rs b/snark/src/work_verify/snark_work_verify_actions.rs
@@ -7,101 +7,62 @@ use super::{SnarkWorkVerifyError, SnarkWorkVerifyId};
 pub type SnarkWorkVerifyActionWithMeta = redux::ActionWithMeta<SnarkWorkVerifyAction>;
 pub type SnarkWorkVerifyActionWithMetaRef<'a> = redux::ActionWithMeta<&'a SnarkWorkVerifyAction>;
 
-#[derive(derive_more::From, Serialize, Deserialize, Debug, Clone)]
-pub enum SnarkWorkVerifyAction {
-    Init(SnarkWorkVerifyInitAction),
-    Pending(SnarkWorkVerifyPendingAction),
-    Error(SnarkWorkVerifyErrorAction),
-    Success(SnarkWorkVerifySuccessAction),
-    Finish(SnarkWorkVerifyFinishAction),
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct SnarkWorkVerifyInitAction {
-    pub req_id: SnarkWorkVerifyId,
-    pub batch: Vec<Snark>,
-    pub sender: String,
-}
-
-impl redux::EnablingCondition<crate::SnarkState> for SnarkWorkVerifyInitAction {
-    fn is_enabled(&self, state: &crate::SnarkState) -> bool {
-        !self.batch.is_empty() && state.work_verify.jobs.next_req_id() == self.req_id
-    }
-}
-
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct SnarkWorkVerifyPendingAction {
-    pub req_id: SnarkWorkVerifyId,
-}
-
-impl redux::EnablingCondition<crate::SnarkState> for SnarkWorkVerifyPendingAction {
-    fn is_enabled(&self, state: &crate::SnarkState) -> bool {
-        state
-            .work_verify
-            .jobs
-            .get(self.req_id)
-            .map_or(false, |v| v.is_init())
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct SnarkWorkVerifyErrorAction {
-    pub req_id: SnarkWorkVerifyId,
-    pub error: SnarkWorkVerifyError,
-}
-
-impl redux::EnablingCondition<crate::SnarkState> for SnarkWorkVerifyErrorAction {
-    fn is_enabled(&self, state: &crate::SnarkState) -> bool {
-        state
-            .work_verify
-            .jobs
-            .get(self.req_id)
-            .map_or(false, |v| v.is_pending())
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct SnarkWorkVerifySuccessAction {
-    pub req_id: SnarkWorkVerifyId,
-}
-
-impl redux::EnablingCondition<crate::SnarkState> for SnarkWorkVerifySuccessAction {
-    fn is_enabled(&self, state: &crate::SnarkState) -> bool {
-        state
-            .work_verify
-            .jobs
-            .get(self.req_id)
-            .map_or(false, |v| v.is_pending())
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct SnarkWorkVerifyFinishAction {
-    pub req_id: SnarkWorkVerifyId,
+pub enum SnarkWorkVerifyAction {
+    Init {
+        req_id: SnarkWorkVerifyId,
+        batch: Vec<Snark>,
+        sender: String,
+    },
+    Pending {
+        req_id: SnarkWorkVerifyId,
+    },
+    Error {
+        req_id: SnarkWorkVerifyId,
+        error: SnarkWorkVerifyError,
+    },
+    Success {
+        req_id: SnarkWorkVerifyId,
+    },
+    Finish {
+        req_id: SnarkWorkVerifyId,
+    },
 }
 
-impl redux::EnablingCondition<crate::SnarkState> for SnarkWorkVerifyFinishAction {
+impl redux::EnablingCondition<crate::SnarkState> for SnarkWorkVerifyAction {
     fn is_enabled(&self, state: &crate::SnarkState) -> bool {
-        state
-            .work_verify
-            .jobs
-            .get(self.req_id)
-            .map_or(false, |v| v.is_finished())
-    }
-}
-
-macro_rules! impl_into_snark_action {
-    ($a:ty) => {
-        impl From<$a> for crate::SnarkAction {
-            fn from(value: $a) -> Self {
-                Self::WorkVerify(value.into())
-            }
+        match self {
+            SnarkWorkVerifyAction::Init { req_id, batch, .. } => {
+                !batch.is_empty() && state.work_verify.jobs.next_req_id() == *req_id
+            },
+            SnarkWorkVerifyAction::Pending { req_id } => {
+                state
+                    .work_verify
+                    .jobs
+                    .get(*req_id)
+                    .map_or(false, |v| v.is_init())
+            },
+            SnarkWorkVerifyAction::Error { req_id, .. } => {
+                state
+                    .work_verify
+                    .jobs
+                    .get(*req_id)
+                    .map_or(false, |v| v.is_pending())
+            },
+            SnarkWorkVerifyAction::Success { req_id } => {
+                state
+                    .work_verify
+                    .jobs
+                    .get(*req_id)
+                    .map_or(false, |v| v.is_pending())
+            },
+            SnarkWorkVerifyAction::Finish { req_id } => {
+                state
+                    .work_verify
+                    .jobs
+                    .get(*req_id)
+                    .map_or(false, |v| v.is_finished())
+            },
         }
-    };
+    }
 }
-
-impl_into_snark_action!(SnarkWorkVerifyInitAction);
-impl_into_snark_action!(SnarkWorkVerifyPendingAction);
-impl_into_snark_action!(SnarkWorkVerifyErrorAction);
-impl_into_snark_action!(SnarkWorkVerifySuccessAction);
-impl_into_snark_action!(SnarkWorkVerifyFinishAction);
diff --git a/snark/src/work_verify/snark_work_verify_effects.rs b/snark/src/work_verify/snark_work_verify_effects.rs
diff --git a/snark/src/work_verify/snark_work_verify_reducer.rs b/snark/src/work_verify/snark_work_verify_reducer.rs
