Port rpc reducer

Author: 0xMimir

node/common/src/service/rpc/mod.rs

@@ -20,14 +20,17 @@ use serde::{Deserialize, Serialize};
 use node::core::channels::{mpsc, oneshot};
 use node::core::requests::PendingRequests;
 use node::p2p::connection::P2pConnectionResponse;
-pub use node::rpc::{
-    ActionStatsResponse, RespondError, RpcActionStatsGetResponse, RpcId, RpcIdType,
-    RpcP2pConnectionOutgoingResponse, RpcScanStateSummaryGetResponse, RpcSnarkPoolGetResponse,
-    RpcSnarkerJobCommitResponse, RpcSnarkerJobSpecResponse, RpcStateGetResponse,
-    RpcSyncStatsGetResponse, RpcTransactionInjectSuccess,
-};
 use node::State;
 use node::{event_source::Event, rpc::RpcSnarkPoolJobGetResponse};
+pub use node::{
+    rpc::{
+        ActionStatsResponse, RpcActionStatsGetResponse, RpcId, RpcIdType,
+        RpcP2pConnectionOutgoingResponse, RpcScanStateSummaryGetResponse, RpcSnarkPoolGetResponse,
+        RpcSnarkerJobCommitResponse, RpcSnarkerJobSpecResponse, RpcStateGetResponse,
+        RpcSyncStatsGetResponse, RpcTransactionInjectSuccess,
+    },
+    rpc_effectful::RespondError,
+};
 
 use crate::NodeService;
 
@@ -176,7 +179,7 @@ fn optimize_filtered_state(
     Ok((value, filter))
 }
 
-impl node::rpc::RpcService for NodeService {
+impl node::rpc_effectful::RpcService for NodeService {
     fn respond_state_get(
         &mut self,
         rpc_id: RpcId,

node/src/action.rs

@@ -12,6 +12,7 @@ pub use crate::ledger::LedgerAction;
 use crate::p2p::callbacks::P2pCallbacksAction;
 pub use crate::p2p::P2pAction;
 pub use crate::rpc::RpcAction;
+use crate::rpc_effectful::RpcEffectfulAction;
 pub use crate::snark::SnarkAction;
 pub use crate::snark_pool::SnarkPoolAction;
 pub use crate::snark_pool::SnarkPoolEffectfulAction;
@@ -48,6 +49,7 @@ pub enum Action {
     ExternalSnarkWorker(ExternalSnarkWorkerAction),
     BlockProducer(BlockProducerAction),
     Rpc(RpcAction),
+    RpcEffectful(RpcEffectfulAction),
 
     WatchedAccounts(WatchedAccountsAction),
 }
@@ -95,6 +97,7 @@ impl redux::EnablingCondition<crate::State> for Action {
             Action::TransactionPool(a) => a.is_enabled(state, time),
             Action::TransactionPoolEffect(a) => a.is_enabled(state, time),
             Action::P2pCallbacks(a) => a.is_enabled(state, time),
+            Action::RpcEffectful(a) => a.is_enabled(state, time),
         }
     }
 }

node/src/action_kind.rs

@@ -73,6 +73,7 @@ use crate::p2p::network::{P2pNetworkAction, P2pNetworkEffectfulAction};
 use crate::p2p::peer::P2pPeerAction;
 use crate::p2p::{P2pAction, P2pEffectfulAction, P2pInitializeAction};
 use crate::rpc::RpcAction;
+use crate::rpc_effectful::RpcEffectfulAction;
 use crate::snark::block_verify::SnarkBlockVerifyAction;
 use crate::snark::block_verify_effectful::SnarkBlockVerifyEffectfulAction;
 use crate::snark::user_command_verify::SnarkUserCommandVerifyAction;
@@ -520,6 +521,38 @@ pub enum ActionKind {
     RpcTransactionPool,
     RpcTransactionStatusGet,
     RpcTransitionFrontierUserCommandsGet,
+    RpcEffectfulActionStatsGet,
+    RpcEffectfulBestChain,
+    RpcEffectfulBlockProducerStatsGet,
+    RpcEffectfulConsensusConstantsGet,
+    RpcEffectfulDiscoveryBoostrapStats,
+    RpcEffectfulDiscoveryRoutingTable,
+    RpcEffectfulGlobalStateGet,
+    RpcEffectfulHealthCheck,
+    RpcEffectfulLedgerAccountsGetSuccess,
+    RpcEffectfulMessageProgressGet,
+    RpcEffectfulP2pConnectionIncomingError,
+    RpcEffectfulP2pConnectionIncomingRespond,
+    RpcEffectfulP2pConnectionIncomingSuccess,
+    RpcEffectfulP2pConnectionOutgoingError,
+    RpcEffectfulP2pConnectionOutgoingSuccess,
+    RpcEffectfulPeersGet,
+    RpcEffectfulReadinessCheck,
+    RpcEffectfulScanStateSummaryGetSuccess,
+    RpcEffectfulSnarkPoolAvailableJobsGet,
+    RpcEffectfulSnarkPoolJobGet,
+    RpcEffectfulSnarkerConfigGet,
+    RpcEffectfulSnarkerJobCommit,
+    RpcEffectfulSnarkerJobSpec,
+    RpcEffectfulSnarkerWorkersGet,
+    RpcEffectfulStatusGet,
+    RpcEffectfulSyncStatsGet,
+    RpcEffectfulTransactionInjectFailure,
+    RpcEffectfulTransactionInjectRejected,
+    RpcEffectfulTransactionInjectSuccess,
+    RpcEffectfulTransactionPool,
+    RpcEffectfulTransactionStatusGet,
+    RpcEffectfulTransitionFrontierUserCommandsGet,
     SnarkBlockVerifyError,
     SnarkBlockVerifyFinish,
     SnarkBlockVerifyInit,
@@ -661,7 +694,7 @@ pub enum ActionKind {
 }
 
 impl ActionKind {
-    pub const COUNT: u16 = 549;
+    pub const COUNT: u16 = 581;
 }
 
 impl std::fmt::Display for ActionKind {
@@ -689,6 +722,7 @@ impl ActionKindGet for Action {
             Self::ExternalSnarkWorker(a) => a.kind(),
             Self::BlockProducer(a) => a.kind(),
             Self::Rpc(a) => a.kind(),
+            Self::RpcEffectful(a) => a.kind(),
             Self::WatchedAccounts(a) => a.kind(),
         }
     }
@@ -1003,6 +1037,69 @@ impl ActionKindGet for RpcAction {
     }
 }
 
+impl ActionKindGet for RpcEffectfulAction {
+    fn kind(&self) -> ActionKind {
+        match self {
+            Self::GlobalStateGet { .. } => ActionKind::RpcEffectfulGlobalStateGet,
+            Self::StatusGet { .. } => ActionKind::RpcEffectfulStatusGet,
+            Self::ActionStatsGet { .. } => ActionKind::RpcEffectfulActionStatsGet,
+            Self::SyncStatsGet { .. } => ActionKind::RpcEffectfulSyncStatsGet,
+            Self::BlockProducerStatsGet { .. } => ActionKind::RpcEffectfulBlockProducerStatsGet,
+            Self::MessageProgressGet { .. } => ActionKind::RpcEffectfulMessageProgressGet,
+            Self::PeersGet { .. } => ActionKind::RpcEffectfulPeersGet,
+            Self::P2pConnectionOutgoingError { .. } => {
+                ActionKind::RpcEffectfulP2pConnectionOutgoingError
+            }
+            Self::P2pConnectionOutgoingSuccess { .. } => {
+                ActionKind::RpcEffectfulP2pConnectionOutgoingSuccess
+            }
+            Self::P2pConnectionIncomingRespond { .. } => {
+                ActionKind::RpcEffectfulP2pConnectionIncomingRespond
+            }
+            Self::P2pConnectionIncomingError { .. } => {
+                ActionKind::RpcEffectfulP2pConnectionIncomingError
+            }
+            Self::P2pConnectionIncomingSuccess { .. } => {
+                ActionKind::RpcEffectfulP2pConnectionIncomingSuccess
+            }
+            Self::ScanStateSummaryGetSuccess { .. } => {
+                ActionKind::RpcEffectfulScanStateSummaryGetSuccess
+            }
+            Self::SnarkPoolAvailableJobsGet { .. } => {
+                ActionKind::RpcEffectfulSnarkPoolAvailableJobsGet
+            }
+            Self::SnarkPoolJobGet { .. } => ActionKind::RpcEffectfulSnarkPoolJobGet,
+            Self::SnarkerConfigGet { .. } => ActionKind::RpcEffectfulSnarkerConfigGet,
+            Self::SnarkerJobCommit { .. } => ActionKind::RpcEffectfulSnarkerJobCommit,
+            Self::SnarkerJobSpec { .. } => ActionKind::RpcEffectfulSnarkerJobSpec,
+            Self::SnarkerWorkersGet { .. } => ActionKind::RpcEffectfulSnarkerWorkersGet,
+            Self::HealthCheck { .. } => ActionKind::RpcEffectfulHealthCheck,
+            Self::ReadinessCheck { .. } => ActionKind::RpcEffectfulReadinessCheck,
+            Self::DiscoveryRoutingTable { .. } => ActionKind::RpcEffectfulDiscoveryRoutingTable,
+            Self::DiscoveryBoostrapStats { .. } => ActionKind::RpcEffectfulDiscoveryBoostrapStats,
+            Self::TransactionPool { .. } => ActionKind::RpcEffectfulTransactionPool,
+            Self::LedgerAccountsGetSuccess { .. } => {
+                ActionKind::RpcEffectfulLedgerAccountsGetSuccess
+            }
+            Self::TransactionInjectSuccess { .. } => {
+                ActionKind::RpcEffectfulTransactionInjectSuccess
+            }
+            Self::TransactionInjectRejected { .. } => {
+                ActionKind::RpcEffectfulTransactionInjectRejected
+            }
+            Self::TransactionInjectFailure { .. } => {
+                ActionKind::RpcEffectfulTransactionInjectFailure
+            }
+            Self::TransitionFrontierUserCommandsGet { .. } => {
+                ActionKind::RpcEffectfulTransitionFrontierUserCommandsGet
+            }
+            Self::BestChain { .. } => ActionKind::RpcEffectfulBestChain,
+            Self::ConsensusConstantsGet { .. } => ActionKind::RpcEffectfulConsensusConstantsGet,
+            Self::TransactionStatusGet { .. } => ActionKind::RpcEffectfulTransactionStatusGet,
+        }
+    }
+}
+
 impl ActionKindGet for WatchedAccountsAction {
     fn kind(&self) -> ActionKind {
         match self {

node/src/effects.rs

@@ -8,7 +8,7 @@ use crate::ledger::ledger_effects;
 use crate::ledger::read::LedgerReadAction;
 use crate::logger::logger_effects;
 use crate::p2p::node_p2p_effects;
-use crate::rpc::rpc_effects;
+use crate::rpc_effectful::rpc_effects;
 use crate::snark::snark_effects;
 use crate::snark_pool::candidate::SnarkPoolCandidateAction;
 use crate::snark_pool::{snark_pool_effects, SnarkPoolAction};
@@ -87,7 +87,10 @@ pub fn effects<S: Service>(store: &mut Store<S>, action: ActionWithMeta) {
         Action::ExternalSnarkWorker(action) => {
             external_snark_worker_effects(store, meta.with_action(action));
         }
-        Action::Rpc(action) => {
+        Action::Rpc(_) => {
+            // Handled by reducer
+        }
+        Action::RpcEffectful(action) => {
             rpc_effects(store, meta.with_action(action));
         }
         Action::WatchedAccounts(_) => {

node/src/lib.rs

@@ -38,6 +38,7 @@ pub mod ledger;
 pub mod logger;
 pub mod p2p;
 pub mod rpc;
+pub mod rpc_effectful;
 pub mod snark;
 pub mod snark_pool;
 pub mod transaction_pool;

node/src/reducer.rs

@@ -1,7 +1,7 @@
 use openmina_core::{bug_condition, error, Substate};
 use p2p::{P2pAction, P2pEffectfulAction, P2pInitializeAction, P2pState};
 
-use crate::{Action, ActionWithMeta, ConsensusAction, EventSourceAction, P2p, State};
+use crate::{rpc::RpcState, Action, ActionWithMeta, ConsensusAction, EventSourceAction, P2p, State};
 
 pub fn reducer(
     state: &mut State,
@@ -87,9 +87,10 @@ pub fn reducer(
         Action::ExternalSnarkWorker(a) => {
             state.external_snark_worker.reducer(meta.with_action(a));
         }
-        Action::Rpc(a) => {
-            state.rpc.reducer(meta.with_action(a));
+        Action::Rpc(action) => {
+            RpcState::reducer(Substate::new(state, dispatcher), meta.with_action(action));
         }
+        Action::RpcEffectful(_) => {}
         Action::WatchedAccounts(a) => {
             crate::watched_accounts::WatchedAccountsState::reducer(
                 Substate::new(state, dispatcher),

node/src/rpc/mod.rs

@@ -25,12 +25,6 @@ pub use rpc_actions::*;
 
 mod rpc_reducer;
 
-mod rpc_effects;
-pub use rpc_effects::*;
-
-mod rpc_service;
-pub use rpc_service::*;
-
 mod rpc_impls;
 
 pub use openmina_core::requests::{RpcId, RpcIdType};
@@ -128,14 +122,14 @@ impl TryFrom<RpcInjectPayment> for MinaBaseUserCommandStableV2 {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub enum ActionStatsQuery {
     SinceStart,
     ForLatestBlock,
     ForBlockWithId(u64),
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub struct SyncStatsQuery {
     pub limit: Option<usize>,
 }
@@ -490,8 +484,8 @@ pub struct RpcBlockProducerStats {
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct RpcSnarkerConfig {
-    public_key: NonZeroCurvePoint,
-    fee: CurrencyFeeStableV1,
+    pub public_key: NonZeroCurvePoint,
+    pub fee: CurrencyFeeStableV1,
 }
 
 #[derive(Serialize, Debug, Clone)]

node/src/rpc/rpc_actions.rs

@@ -19,9 +19,6 @@ use super::{
     SyncStatsQuery,
 };
 
-pub type RpcActionWithMeta = redux::ActionWithMeta<RpcAction>;
-pub type RpcActionWithMetaRef<'a> = redux::ActionWithMeta<&'a RpcAction>;
-
 #[derive(Serialize, Deserialize, Debug, Clone, ActionEvent)]
 pub enum RpcAction {
     GlobalStateGet {