Review fixes

Author: 0xMimir

node/src/state.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use mina_p2p_messages::v2::{MinaBaseUserCommandStableV2, MinaBlockBlockStableV2};
 
 use openmina_core::block::BlockWithHash;
-use openmina_core::requests::{RequestId, RpcIdType};
+use openmina_core::requests::RpcId;
 use openmina_core::snark::{Snark, SnarkInfo};
 use openmina_core::{
     block::ArcBlockWithHash, consensus::ConsensusConstants, constants::constraint_constants, error,
@@ -395,27 +395,27 @@ impl P2p {
                 }
             )),
             on_p2p_connection_outgoing_error: Some(redux::callback!(
-                on_p2p_connection_outgoing_error((rpc_id: RequestId<RpcIdType>, error: P2pConnectionOutgoingError)) -> crate::Action{
+                on_p2p_connection_outgoing_error((rpc_id: RpcId, error: P2pConnectionOutgoingError)) -> crate::Action{
                     RpcAction::P2pConnectionOutgoingError { rpc_id, error }
                 }
             )),
             on_p2p_connection_outgoing_success: Some(redux::callback!(
-                on_p2p_connection_outgoing_success(rpc_id: RequestId<RpcIdType>) -> crate::Action{
+                on_p2p_connection_outgoing_success(rpc_id: RpcId) -> crate::Action{
                     RpcAction::P2pConnectionOutgoingSuccess { rpc_id }
                 }
             )),
             on_p2p_connection_incoming_error: Some(redux::callback!(
-                on_p2p_connection_incoming_error((rpc_id: RequestId<RpcIdType>, error: String)) -> crate::Action{
+                on_p2p_connection_incoming_error((rpc_id: RpcId, error: String)) -> crate::Action{
                     RpcAction::P2pConnectionIncomingError { rpc_id, error }
                 }
             )),
             on_p2p_connection_incoming_success: Some(redux::callback!(
-                on_p2p_connection_incoming_success(rpc_id: RequestId<RpcIdType>) -> crate::Action{
+                on_p2p_connection_incoming_success(rpc_id: RpcId) -> crate::Action{
                     RpcAction::P2pConnectionIncomingSuccess { rpc_id }
                 }
             )),
             on_p2p_connection_incoming_answer_ready: Some(redux::callback!(
-                on_p2p_connection_incoming_answer_ready((rpc_id: RequestId<RpcIdType>, peer_id: PeerId, answer: P2pConnectionResponse)) -> crate::Action{
+                on_p2p_connection_incoming_answer_ready((rpc_id: RpcId, peer_id: PeerId, answer: P2pConnectionResponse)) -> crate::Action{
                     RpcAction::P2pConnectionIncomingAnswerReady { rpc_id, answer, peer_id }
                 }
             )),

p2p/src/p2p_state.rs

@@ -1,7 +1,7 @@
 use openmina_core::{
     block::{ArcBlockWithHash, BlockWithHash},
     impl_substate_access,
-    requests::{RequestId, RpcId, RpcIdType},
+    requests::RpcId,
     snark::{Snark, SnarkInfo, SnarkJobCommitment},
     ChainId, SubstateAccess,
 };
@@ -491,38 +491,56 @@ type OptionalCallback<T> = Option<Callback<T>>;
 
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub struct P2pCallbacks {
+    /// Callback for [`P2pChannelsTransactionAction::Libp2pReceived`]
     pub on_p2p_channels_transaction_libp2p_received:
         OptionalCallback<Box<MinaBaseUserCommandStableV2>>,
+    /// Callback for [`P2pChannelsSnarkJobCommitmentAction::Received`]
     pub on_p2p_channels_snark_job_commitment_received:
         OptionalCallback<(PeerId, Box<SnarkJobCommitment>)>,
 
+    /// Callback for [`P2pChannelsSnarkAction::Received`]
     pub on_p2p_channels_snark_received: OptionalCallback<(PeerId, Box<SnarkInfo>)>,
+    /// Callback for [`P2pChannelsSnarkAction::Libp2pReceived`]
     pub on_p2p_channels_snark_libp2p_received: OptionalCallback<(PeerId, Box<Snark>)>,
 
+    /// Callback for [`P2pChannelsBestTipAction::RequestReceived`]
     pub on_p2p_channels_best_tip_request_received: OptionalCallback<PeerId>,
 
+    /// Callback for [`P2pDisconnectionAction::Finish`]
     pub on_p2p_disconnection_finish: OptionalCallback<PeerId>,
 
-    pub on_p2p_connection_outgoing_error:
-        OptionalCallback<(RequestId<RpcIdType>, P2pConnectionOutgoingError)>,
-    pub on_p2p_connection_outgoing_success: OptionalCallback<RequestId<RpcIdType>>,
+    /// Callback for [`P2pConnectionOutgoingAction::Error`]
+    pub on_p2p_connection_outgoing_error: OptionalCallback<(RpcId, P2pConnectionOutgoingError)>,
+    /// Callback for [`P2pConnectionOutgoingAction::Success`]
+    pub on_p2p_connection_outgoing_success: OptionalCallback<RpcId>,
 
-    pub on_p2p_connection_incoming_error: OptionalCallback<(RequestId<RpcIdType>, String)>,
-    pub on_p2p_connection_incoming_success: OptionalCallback<RequestId<RpcIdType>>,
+    /// Callback for [`P2pConnectionIncomingAction::Error`]
+    pub on_p2p_connection_incoming_error: OptionalCallback<(RpcId, String)>,
+    /// Callback for [`P2pConnectionIncomingAction::Success`]
+    pub on_p2p_connection_incoming_success: OptionalCallback<RpcId>,
+    /// Callback for [`P2pConnectionIncomingAction::AnswerReady`]
     pub on_p2p_connection_incoming_answer_ready:
-        OptionalCallback<(RequestId<RpcIdType>, PeerId, P2pConnectionResponse)>,
+        OptionalCallback<(RpcId, PeerId, P2pConnectionResponse)>,
 
+    /// Callback for [`P2pPeerAction::BestTipUpdate`]
     pub on_p2p_peer_best_tip_update: OptionalCallback<BlockWithHash<Arc<MinaBlockBlockStableV2>>>,
 
+    /// Callback for [`P2pChannelsRpcAction::Ready`]
     pub on_p2p_channels_rpc_ready: OptionalCallback<PeerId>,
+    /// Callback for [`P2pChannelsRpcAction::Timeout`]
     pub on_p2p_channels_rpc_timeout: OptionalCallback<(PeerId, P2pRpcId)>,
+    /// Callback for [`P2pChannelsRpcAction::ResponseReceived`]
     pub on_p2p_channels_rpc_response_received:
         OptionalCallback<(PeerId, P2pRpcId, Option<Box<P2pRpcResponse>>)>,
+    /// Callback for [`P2pChannelsRpcAction::RequestReceived`]
     pub on_p2p_channels_rpc_request_received:
         OptionalCallback<(PeerId, P2pRpcId, Box<P2pRpcRequest>)>,
 
+    /// Callback for [`P2pChannelsStreamingRpcAction::Ready`]
     pub on_p2p_channels_streaming_rpc_ready: OptionalCallback<()>,
+    /// Callback for [`P2pChannelsStreamingRpcAction::Timeout`]
     pub on_p2p_channels_streaming_rpc_timeout: OptionalCallback<(PeerId, P2pRpcId)>,
+    /// Callback for [`P2pChannelsStreamingRpcAction::ResponseReceived`]
     pub on_p2p_channels_streaming_rpc_response_received:
         OptionalCallback<(PeerId, P2pRpcId, Option<P2pStreamingRpcResponseFull>)>,
 }