fixup: Update substate access to handle p2p readiness

node/src/action.rs

@@ -65,7 +65,13 @@ impl redux::EnablingCondition<crate::State> for Action {
         match self {
             Action::CheckTimeouts(a) => a.is_enabled(state, time),
             Action::EventSource(a) => a.is_enabled(state, time),
-            Action::P2p(a) => a.is_enabled(&state.p2p, time),
+            Action::P2p(a) => match a {
+                P2pAction::Initialization(a) => a.is_enabled(state, time),
+                other => state
+                    .p2p
+                    .ready()
+                    .map_or(false, |p2p| other.is_enabled(p2p, time)),
+            },
             Action::Ledger(a) => a.is_enabled(state, time),
             Action::Snark(a) => a.is_enabled(&state.snark, time),
             Action::Consensus(a) => a.is_enabled(state, time),

node/src/reducer.rs

@@ -16,9 +16,22 @@ pub fn reducer(
         },
         Action::EventSource(_) => {}
 
-        Action::P2p(a) => {
-            p2p::P2pState::reducer(Substate::new(state, dispatcher), meta.with_action(a));
-        }
+        Action::P2p(a) => match a {
+            P2pAction::Initialization(P2pInitializeAction::Initialize { chain_id }) => {
+                if let Err(err) = state.p2p.initialize(chain_id) {
+                    error!(meta.time(); summary = "error initializing p2p", error = display(err));
+                }
+            }
+            action => match &mut state.p2p {
+                P2p::Pending(_) => {
+                    error!(meta.time(); summary = "p2p is not initialized", action = debug(action))
+                }
+                P2p::Ready(_) => p2p::P2pState::reducer(
+                    Substate::new(state, dispatcher),
+                    meta.with_action(action),
+                ),
+            },
+        },
         Action::Ledger(a) => {
             state.ledger.reducer(meta.with_action(a));
         }
@@ -66,22 +79,3 @@ pub fn reducer(
     // must be the last.
     state.action_applied(action);
 }
-
-impl P2p {
-    fn reduce(&mut self, action: redux::ActionWithMeta<&P2pAction>) {
-        let (action, meta) = action.split();
-        match action {
-            P2pAction::Initialization(P2pInitializeAction::Initialize { chain_id }) => {
-                if let Err(err) = self.initialize(chain_id) {
-                    error!(meta.time(); summary = "error initializing p2p", error = display(err));
-                }
-            }
-            action => match self {
-                P2p::Pending(_) => {
-                    error!(meta.time(); summary = "p2p is not initialized", action = debug(action))
-                }
-                P2p::Ready(p2p_state) => p2p_state.reducer(meta.with_action(action)),
-            },
-        }
-    }
-}

node/src/state.rs

@@ -49,8 +49,6 @@ pub struct State {
 // Substate accessors that will be used in reducers
 use openmina_core::impl_substate_access;
 
-impl_substate_access!(State, P2pState, p2p);
-impl_substate_access!(State, p2p::P2pNetworkState, p2p.network);
 impl_substate_access!(State, SnarkState, snark);
 impl_substate_access!(State, SnarkBlockVerifyState, snark.block_verify);
 impl_substate_access!(State, SnarkWorkVerifyState, snark.work_verify);
@@ -69,6 +67,26 @@ impl_substate_access!(State, BlockProducerState, block_producer);
 impl_substate_access!(State, RpcState, rpc);
 impl_substate_access!(State, WatchedAccountsState, watched_accounts);
 
+impl openmina_core::SubstateAccess<P2pState> for State {
+    fn substate(&self) -> &P2pState {
+        self.p2p.ready().unwrap()
+    }
+
+    fn substate_mut(&mut self) -> &mut P2pState {
+        self.p2p.ready_mut().unwrap()
+    }
+}
+
+impl openmina_core::SubstateAccess<p2p::P2pNetworkState> for State {
+    fn substate(&self) -> &p2p::P2pNetworkState {
+        &self.p2p.ready().unwrap().network
+    }
+
+    fn substate_mut(&mut self) -> &mut p2p::P2pNetworkState {
+        &mut self.p2p.ready_mut().unwrap().network
+    }
+}
+
 impl openmina_core::SubstateAccess<TransitionFrontierSyncLedgerState> for State {
     fn substate(&self) -> &TransitionFrontierSyncLedgerState {
         self.transition_frontier.sync.ledger().unwrap()
@@ -230,6 +248,14 @@ impl P2p {
         }
     }
 
+    pub fn ready_mut(&mut self) -> Option<&mut P2pState> {
+        if let P2p::Ready(state) = self {
+            Some(state)
+        } else {
+            None
+        }
+    }
+
     pub fn unwrap(&self) -> &P2pState {
         self.ready().expect("p2p is not initialized")
     }