fix(p2p): p2p testing crate compilation error and clippy errors

binier · binier · commit e0947ceabbb3 · 2024-10-15T02:19:53.000+04:00
diff --git a/p2p/src/channels/signaling/discovery/p2p_channels_signaling_discovery_reducer.rs b/p2p/src/channels/signaling/discovery/p2p_channels_signaling_discovery_reducer.rs
@@ -366,7 +366,7 @@ impl P2pChannelsSignalingDiscoveryState {
                     P2pConnectionResponse::Rejected(reason) => {
                         dispatcher.push(P2pConnectionOutgoingAction::AnswerRecvError {
                             peer_id: target_public_key.peer_id(),
-                            error: P2pConnectionErrorResponse::Rejected(reason.clone()),
+                            error: P2pConnectionErrorResponse::Rejected(*reason),
                         })
                     }
                     P2pConnectionResponse::SignalDecryptionFailed => {
diff --git a/p2p/src/channels/signaling/discovery/p2p_channels_signaling_discovery_state.rs b/p2p/src/channels/signaling/discovery/p2p_channels_signaling_discovery_state.rs
@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::identity::PublicKey;
 
+#[allow(clippy::large_enum_variant)]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub enum P2pChannelsSignalingDiscoveryState {
     Disabled,
diff --git a/p2p/src/channels/signaling/exchange/p2p_channels_signaling_exchange_state.rs b/p2p/src/channels/signaling/exchange/p2p_channels_signaling_exchange_state.rs
@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::identity::PublicKey;
 
+#[allow(clippy::large_enum_variant)]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub enum P2pChannelsSignalingExchangeState {
     Disabled,
diff --git a/p2p/src/channels/signaling/mod.rs b/p2p/src/channels/signaling/mod.rs
@@ -52,9 +52,7 @@ impl crate::P2pState {
 
         // TODO(binier): maybe randomize
         for requester in requests {
-            if let Some(target_peer_id) =
-                available_peers.iter().filter(|&&id| id != requester).next()
-            {
+            if let Some(target_peer_id) = available_peers.iter().find(|&&id| id != requester) {
                 let target_peer_id = *target_peer_id;
                 dispatcher.push(P2pChannelsSignalingDiscoveryAction::DiscoveredSend {
                     peer_id: *requester,
diff --git a/p2p/src/channels/signaling/p2p_channels_signaling_state.rs b/p2p/src/channels/signaling/p2p_channels_signaling_state.rs
@@ -25,15 +25,16 @@ impl P2pChannelsSignalingState {
 
     pub fn received_discovered_peer_id(&self) -> Option<PeerId> {
         match &self.discovery {
-            P2pChannelsSignalingDiscoveryState::Ready { remote, .. } => match remote {
-                SignalingDiscoveryState::Discovered {
-                    target_public_key, ..
-                }
-                | SignalingDiscoveryState::DiscoveredAccepted {
-                    target_public_key, ..
-                } => Some(target_public_key.peer_id()),
-                _ => None,
-            },
+            P2pChannelsSignalingDiscoveryState::Ready {
+                remote:
+                    SignalingDiscoveryState::Discovered {
+                        target_public_key, ..
+                    }
+                    | SignalingDiscoveryState::DiscoveredAccepted {
+                        target_public_key, ..
+                    },
+                ..
+            } => Some(target_public_key.peer_id()),
             _ => None,
         }
     }
@@ -49,25 +50,27 @@ impl P2pChannelsSignalingState {
 
     pub fn sent_discovered_peer_id(&self) -> Option<PeerId> {
         match &self.discovery {
-            P2pChannelsSignalingDiscoveryState::Ready { local, .. } => match local {
-                SignalingDiscoveryState::Discovered {
-                    target_public_key, ..
-                }
-                | SignalingDiscoveryState::DiscoveredAccepted {
-                    target_public_key, ..
-                } => Some(target_public_key.peer_id()),
-                _ => None,
-            },
+            P2pChannelsSignalingDiscoveryState::Ready {
+                local:
+                    SignalingDiscoveryState::Discovered {
+                        target_public_key, ..
+                    }
+                    | SignalingDiscoveryState::DiscoveredAccepted {
+                        target_public_key, ..
+                    },
+                ..
+            } => Some(target_public_key.peer_id()),
             _ => None,
         }
     }
 
     pub fn is_looking_for_incoming_peer(&self) -> bool {
-        match &self.exchange {
-            P2pChannelsSignalingExchangeState::Ready { remote, .. } => {
-                matches!(remote, SignalingExchangeState::Requested { .. })
+        matches!(
+            self.exchange,
+            P2pChannelsSignalingExchangeState::Ready {
+                remote: SignalingExchangeState::Requested { .. },
+                ..
             }
-            _ => false,
-        }
+        )
     }
 }
diff --git a/p2p/src/connection/incoming/p2p_connection_incoming_reducer.rs b/p2p/src/connection/incoming/p2p_connection_incoming_reducer.rs
@@ -144,7 +144,7 @@ impl P2pConnectionIncomingState {
             }
             P2pConnectionIncomingAction::AnswerReady { peer_id, answer } => {
                 let state = p2p_state
-                    .incoming_peer_connection_mut(&peer_id)
+                    .incoming_peer_connection_mut(peer_id)
                     .ok_or_else(|| format!("Invalid state for: {:?}", action))?;
 
                 let Self::AnswerSdpCreateSuccess {
@@ -187,7 +187,7 @@ impl P2pConnectionIncomingState {
                     }
                 }
 
-                if let Some(rpc_id) = p2p_state.peer_connection_rpc_id(&peer_id) {
+                if let Some(rpc_id) = p2p_state.peer_connection_rpc_id(peer_id) {
                     if let Some(callback) =
                         &p2p_state.callbacks.on_p2p_connection_incoming_answer_ready
                     {
diff --git a/p2p/src/identity/secret_key.rs b/p2p/src/identity/secret_key.rs
@@ -155,6 +155,16 @@ impl TryFrom<SecretKey> for libp2p_identity::Keypair {
     }
 }
 
+#[cfg(feature = "p2p-libp2p")]
+impl TryFrom<libp2p_identity::Keypair> for SecretKey {
+    type Error = ();
+
+    fn try_from(value: libp2p_identity::Keypair) -> Result<Self, Self::Error> {
+        let bytes = value.try_into_ed25519().or(Err(()))?.to_bytes();
+        Ok(Self::from_bytes(bytes[0..32].try_into().or(Err(()))?))
+    }
+}
+
 impl Serialize for SecretKey {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
diff --git a/p2p/src/service_impl/mod.rs b/p2p/src/service_impl/mod.rs
@@ -21,7 +21,7 @@ pub mod webrtc {
     use crate::{
         channels::{ChannelId, ChannelMsg, MsgId},
         connection::outgoing::P2pConnectionOutgoingInitOpts,
-        identity::SecretKey,
+        identity::{EncryptableType, PublicKey, SecretKey},
         webrtc, P2pEvent, PeerId,
     };
 
@@ -72,5 +72,17 @@ pub mod webrtc {
         fn channel_open(&mut self, peer_id: PeerId, id: ChannelId) {}
 
         fn channel_send(&mut self, peer_id: PeerId, msg_id: MsgId, msg: ChannelMsg) {}
+
+        fn encrypt<T: EncryptableType>(
+            &mut self,
+            other_pk: &PublicKey,
+            message: &T,
+        ) -> Result<T::Encrypted, ()>;
+
+        fn decrypt<T: EncryptableType>(
+            &mut self,
+            other_pub_key: &PublicKey,
+            encrypted: &T::Encrypted,
+        ) -> Result<T, ()>;
     }
 }
diff --git a/p2p/testing/src/redux.rs b/p2p/testing/src/redux.rs
@@ -12,10 +12,18 @@ use openmina_core::{
 use p2p::{
     bootstrap::P2pNetworkKadBootstrapState,
     channels::{
-        best_tip::P2pChannelsBestTipAction, best_tip_effectful::P2pChannelsBestTipEffectfulAction,
-        rpc::P2pChannelsRpcAction, rpc_effectful::P2pChannelsRpcEffectfulAction,
-        signaling::exchange_effectful::P2pChannelsSignalingExchangeEffectfulAction,
-        snark::P2pChannelsSnarkAction, snark_effectful::P2pChannelsSnarkEffectfulAction,
+        best_tip::P2pChannelsBestTipAction,
+        best_tip_effectful::P2pChannelsBestTipEffectfulAction,
+        rpc::P2pChannelsRpcAction,
+        rpc_effectful::P2pChannelsRpcEffectfulAction,
+        signaling::{
+            discovery::P2pChannelsSignalingDiscoveryAction,
+            discovery_effectful::P2pChannelsSignalingDiscoveryEffectfulAction,
+            exchange::P2pChannelsSignalingExchangeAction,
+            exchange_effectful::P2pChannelsSignalingExchangeEffectfulAction,
+        },
+        snark::P2pChannelsSnarkAction,
+        snark_effectful::P2pChannelsSnarkEffectfulAction,
         snark_job_commitment::P2pChannelsSnarkJobCommitmentAction,
         snark_job_commitment_effectful::P2pChannelsSnarkJobCommitmentEffectfulAction,
         streaming_rpc::P2pChannelsStreamingRpcAction,
@@ -287,6 +295,8 @@ impl_from_p2p!(p2p::P2pNetworkPnetAction);
 impl_from_p2p!(p2p::P2pNetworkNoiseAction);
 impl_from_p2p!(p2p::connection::incoming::P2pConnectionIncomingAction);
 impl_from_p2p!(p2p::P2pNetworkPubsubAction);
+impl_from_p2p!(P2pChannelsSignalingDiscoveryAction);
+impl_from_p2p!(P2pChannelsSignalingExchangeAction);
 impl_from_p2p!(P2pChannelsTransactionAction);
 impl_from_p2p!(P2pChannelsSnarkAction);
 impl_from_p2p!(p2p::P2pNetworkRpcAction);
@@ -304,6 +314,7 @@ impl_from_p2p!(effectful p2p::P2pNetworkPubsubEffectfulAction);
 impl_from_p2p!(effectful P2pNetworkIdentifyStreamEffectfulAction);
 impl_from_p2p!(effectful P2pConnectionOutgoingEffectfulAction);
 impl_from_p2p!(effectful P2pDisconnectionEffectfulAction);
+impl_from_p2p!(effectful P2pChannelsSignalingDiscoveryEffectfulAction);
 impl_from_p2p!(effectful P2pChannelsSignalingExchangeEffectfulAction);
 impl_from_p2p!(effectful P2pChannelsBestTipEffectfulAction);
 impl_from_p2p!(effectful P2pChannelsStreamingRpcEffectfulAction);
diff --git a/p2p/testing/src/service.rs b/p2p/testing/src/service.rs
@@ -99,6 +99,22 @@ impl P2pServiceWebrtc for ClusterService {
     ) -> &mut std::collections::BTreeMap<p2p::PeerId, p2p::service_impl::webrtc::PeerState> {
         &mut self.peers
     }
+
+    fn encrypt<T: p2p::identity::EncryptableType>(
+        &mut self,
+        _other_pk: &p2p::identity::PublicKey,
+        _message: &T,
+    ) -> Result<T::Encrypted, ()> {
+        unreachable!("this is webrtc only and this crate tests libp2p only")
+    }
+
+    fn decrypt<T: p2p::identity::EncryptableType>(
+        &mut self,
+        _other_pub_key: &p2p::identity::PublicKey,
+        _encrypted: &T::Encrypted,
+    ) -> Result<T, ()> {
+        unreachable!("this is webrtc only and this crate tests libp2p only")
+    }
 }
 
 impl P2pCryptoService for ClusterService {

Original file line number	Diff line number	Diff line change
`@@ -366,7 +366,7 @@ impl P2pChannelsSignalingDiscoveryState {`
`366`	`366`	`P2pConnectionResponse::Rejected(reason) => {`
`367`	`367`	`dispatcher.push(P2pConnectionOutgoingAction::AnswerRecvError {`
`368`	`368`	`peer_id: target_public_key.peer_id(),`
`369`		`- error: P2pConnectionErrorResponse::Rejected(reason.clone()),`
	`369`	`+ error: P2pConnectionErrorResponse::Rejected(*reason),`
`370`	`370`	`})`
`371`	`371`	`}`
`372`	`372`	`P2pConnectionResponse::SignalDecryptionFailed => {`
Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ impl P2pConnectionIncomingState {`
`144`	`144`	`}`
`145`	`145`	`P2pConnectionIncomingAction::AnswerReady { peer_id, answer } => {`
`146`	`146`	`let state = p2p_state`
`147`		`- .incoming_peer_connection_mut(&peer_id)`
	`147`	`+ .incoming_peer_connection_mut(peer_id)`
`148`	`148`	`.ok_or_else(\|\| format!("Invalid state for: {:?}", action))?;`
`149`	`149`
`150`	`150`	`let Self::AnswerSdpCreateSuccess {`
`@@ -187,7 +187,7 @@ impl P2pConnectionIncomingState {`
`187`	`187`	`}`
`188`	`188`	`}`
`189`	`189`
`190`		`- if let Some(rpc_id) = p2p_state.peer_connection_rpc_id(&peer_id) {`
	`190`	`+ if let Some(rpc_id) = p2p_state.peer_connection_rpc_id(peer_id) {`
`191`	`191`	`if let Some(callback) =`
`192`	`192`	`&p2p_state.callbacks.on_p2p_connection_incoming_answer_ready`
`193`	`193`	`{`