feat(p2p/webrtc): signaling discovery

re: #772

Author: binier

node/src/action_kind.rs

@@ -28,6 +28,8 @@ use crate::p2p::channels::best_tip::P2pChannelsBestTipAction;
 use crate::p2p::channels::best_tip_effectful::P2pChannelsBestTipEffectfulAction;
 use crate::p2p::channels::rpc::P2pChannelsRpcAction;
 use crate::p2p::channels::rpc_effectful::P2pChannelsRpcEffectfulAction;
+use crate::p2p::channels::signaling::discovery::P2pChannelsSignalingDiscoveryAction;
+use crate::p2p::channels::signaling::discovery_effectful::P2pChannelsSignalingDiscoveryEffectfulAction;
 use crate::p2p::channels::signaling::exchange::P2pChannelsSignalingExchangeAction;
 use crate::p2p::channels::signaling::exchange_effectful::P2pChannelsSignalingExchangeEffectfulAction;
 use crate::p2p::channels::snark::P2pChannelsSnarkAction;
@@ -211,6 +213,26 @@ pub enum ActionKind {
     P2pChannelsRpcEffectfulInit,
     P2pChannelsRpcEffectfulRequestSend,
     P2pChannelsRpcEffectfulResponseSend,
+    P2pChannelsSignalingDiscoveryAnswerDecrypted,
+    P2pChannelsSignalingDiscoveryAnswerReceived,
+    P2pChannelsSignalingDiscoveryAnswerSend,
+    P2pChannelsSignalingDiscoveryDiscoveredAccept,
+    P2pChannelsSignalingDiscoveryDiscoveredAcceptReceived,
+    P2pChannelsSignalingDiscoveryDiscoveredReceived,
+    P2pChannelsSignalingDiscoveryDiscoveredReject,
+    P2pChannelsSignalingDiscoveryDiscoveredRejectReceived,
+    P2pChannelsSignalingDiscoveryDiscoveredSend,
+    P2pChannelsSignalingDiscoveryDiscoveryRequestReceived,
+    P2pChannelsSignalingDiscoveryDiscoveryRequestSend,
+    P2pChannelsSignalingDiscoveryInit,
+    P2pChannelsSignalingDiscoveryPending,
+    P2pChannelsSignalingDiscoveryReady,
+    P2pChannelsSignalingDiscoveryRequestReceived,
+    P2pChannelsSignalingDiscoveryRequestSend,
+    P2pChannelsSignalingDiscoveryEffectfulAnswerDecrypt,
+    P2pChannelsSignalingDiscoveryEffectfulInit,
+    P2pChannelsSignalingDiscoveryEffectfulMessageSend,
+    P2pChannelsSignalingDiscoveryEffectfulOfferEncryptAndSend,
     P2pChannelsSignalingExchangeAnswerReceived,
     P2pChannelsSignalingExchangeAnswerSend,
     P2pChannelsSignalingExchangeInit,
@@ -635,7 +657,7 @@ pub enum ActionKind {
 }
 
 impl ActionKind {
-    pub const COUNT: u16 = 525;
+    pub const COUNT: u16 = 545;
 }
 
 impl std::fmt::Display for ActionKind {
@@ -1046,6 +1068,7 @@ impl ActionKindGet for P2pChannelsAction {
     fn kind(&self) -> ActionKind {
         match self {
             Self::MessageReceived(a) => a.kind(),
+            Self::SignalingDiscovery(a) => a.kind(),
             Self::SignalingExchange(a) => a.kind(),
             Self::BestTip(a) => a.kind(),
             Self::Transaction(a) => a.kind(),
@@ -1087,6 +1110,7 @@ impl ActionKindGet for P2pNetworkAction {
 impl ActionKindGet for P2pChannelsEffectfulAction {
     fn kind(&self) -> ActionKind {
         match self {
+            Self::SignalingDiscovery(a) => a.kind(),
             Self::SignalingExchange(a) => a.kind(),
             Self::BestTip(a) => a.kind(),
             Self::Rpc(a) => a.kind(),
@@ -1419,6 +1443,47 @@ impl ActionKindGet for P2pChannelsMessageReceivedAction {
     }
 }
 
+impl ActionKindGet for P2pChannelsSignalingDiscoveryAction {
+    fn kind(&self) -> ActionKind {
+        match self {
+            Self::Init { .. } => ActionKind::P2pChannelsSignalingDiscoveryInit,
+            Self::Pending { .. } => ActionKind::P2pChannelsSignalingDiscoveryPending,
+            Self::Ready { .. } => ActionKind::P2pChannelsSignalingDiscoveryReady,
+            Self::RequestSend { .. } => ActionKind::P2pChannelsSignalingDiscoveryRequestSend,
+            Self::DiscoveryRequestReceived { .. } => {
+                ActionKind::P2pChannelsSignalingDiscoveryDiscoveryRequestReceived
+            }
+            Self::DiscoveredSend { .. } => ActionKind::P2pChannelsSignalingDiscoveryDiscoveredSend,
+            Self::DiscoveredRejectReceived { .. } => {
+                ActionKind::P2pChannelsSignalingDiscoveryDiscoveredRejectReceived
+            }
+            Self::DiscoveredAcceptReceived { .. } => {
+                ActionKind::P2pChannelsSignalingDiscoveryDiscoveredAcceptReceived
+            }
+            Self::AnswerSend { .. } => ActionKind::P2pChannelsSignalingDiscoveryAnswerSend,
+            Self::RequestReceived { .. } => {
+                ActionKind::P2pChannelsSignalingDiscoveryRequestReceived
+            }
+            Self::DiscoveryRequestSend { .. } => {
+                ActionKind::P2pChannelsSignalingDiscoveryDiscoveryRequestSend
+            }
+            Self::DiscoveredReceived { .. } => {
+                ActionKind::P2pChannelsSignalingDiscoveryDiscoveredReceived
+            }
+            Self::DiscoveredReject { .. } => {
+                ActionKind::P2pChannelsSignalingDiscoveryDiscoveredReject
+            }
+            Self::DiscoveredAccept { .. } => {
+                ActionKind::P2pChannelsSignalingDiscoveryDiscoveredAccept
+            }
+            Self::AnswerReceived { .. } => ActionKind::P2pChannelsSignalingDiscoveryAnswerReceived,
+            Self::AnswerDecrypted { .. } => {
+                ActionKind::P2pChannelsSignalingDiscoveryAnswerDecrypted
+            }
+        }
+    }
+}
+
 impl ActionKindGet for P2pChannelsSignalingExchangeAction {
     fn kind(&self) -> ActionKind {
         match self {
@@ -1693,6 +1758,23 @@ impl ActionKindGet for P2pNetworkRpcAction {
     }
 }
 
+impl ActionKindGet for P2pChannelsSignalingDiscoveryEffectfulAction {
+    fn kind(&self) -> ActionKind {
+        match self {
+            Self::Init { .. } => ActionKind::P2pChannelsSignalingDiscoveryEffectfulInit,
+            Self::MessageSend { .. } => {
+                ActionKind::P2pChannelsSignalingDiscoveryEffectfulMessageSend
+            }
+            Self::OfferEncryptAndSend { .. } => {
+                ActionKind::P2pChannelsSignalingDiscoveryEffectfulOfferEncryptAndSend
+            }
+            Self::AnswerDecrypt { .. } => {
+                ActionKind::P2pChannelsSignalingDiscoveryEffectfulAnswerDecrypt
+            }
+        }
+    }
+}
+
 impl ActionKindGet for P2pChannelsSignalingExchangeEffectfulAction {
     fn kind(&self) -> ActionKind {
         match self {

node/src/event_source/event_source_effects.rs

@@ -1,3 +1,4 @@
+use p2p::channels::signaling::discovery::P2pChannelsSignalingDiscoveryAction;
 use p2p::channels::signaling::exchange::P2pChannelsSignalingExchangeAction;
 use p2p::channels::snark::P2pChannelsSnarkAction;
 use p2p::channels::streaming_rpc::P2pChannelsStreamingRpcAction;
@@ -202,6 +203,11 @@ pub fn event_source_effects<S: Service>(store: &mut Store<S>, action: EventSourc
                             // TODO(binier): dispatch error action.
                         }
                         Ok(_) => match chan_id {
+                            ChannelId::SignalingDiscovery => {
+                                store.dispatch(P2pChannelsSignalingDiscoveryAction::Ready {
+                                    peer_id,
+                                });
+                            }
                             ChannelId::SignalingExchange => {
                                 store.dispatch(P2pChannelsSignalingExchangeAction::Ready {
                                     peer_id,

node/src/logger/logger_effects.rs

@@ -69,6 +69,7 @@ pub fn logger_effects<S: Service>(store: &Store<S>, action: ActionWithMetaRef<'_
             P2pAction::Identify(action) => action.action_event(&context),
             P2pAction::Channels(action) => match action {
                 P2pChannelsAction::MessageReceived(action) => action.action_event(&context),
+                P2pChannelsAction::SignalingDiscovery(action) => action.action_event(&context),
                 P2pChannelsAction::SignalingExchange(action) => action.action_event(&context),
                 P2pChannelsAction::BestTip(action) => action.action_event(&context),
                 P2pChannelsAction::Transaction(action) => action.action_event(&context),
@@ -106,6 +107,9 @@ pub fn logger_effects<S: Service>(store: &Store<S>, action: ActionWithMetaRef<'_
         },
         Action::P2pEffectful(action) => match action {
             p2p::P2pEffectfulAction::Channels(action) => match action {
+                P2pChannelsEffectfulAction::SignalingDiscovery(action) => {
+                    action.action_event(&context)
+                }
                 P2pChannelsEffectfulAction::SignalingExchange(action) => {
                     action.action_event(&context)
                 }

node/src/p2p/channels/signaling/mod.rs

@@ -1,3 +1,4 @@
 pub use ::p2p::channels::signaling::*;
 
+mod p2p_channels_signaling_discovery_actions;
 mod p2p_channels_signaling_exchange_actions;

node/src/p2p/channels/signaling/p2p_channels_signaling_discovery_actions.rs

@@ -0,0 +1,7 @@
+use super::discovery::*;
+
+impl redux::EnablingCondition<crate::State> for P2pChannelsSignalingDiscoveryAction {
+    fn is_enabled(&self, state: &crate::State, time: redux::Timestamp) -> bool {
+        state.p2p.is_enabled(self, time)
+    }
+}

node/src/p2p/mod.rs

@@ -3,7 +3,10 @@ use p2p::{
     channels::{
         best_tip_effectful::P2pChannelsBestTipEffectfulAction,
         rpc_effectful::P2pChannelsRpcEffectfulAction,
-        signaling::exchange_effectful::P2pChannelsSignalingExchangeEffectfulAction,
+        signaling::{
+            discovery_effectful::P2pChannelsSignalingDiscoveryEffectfulAction,
+            exchange_effectful::P2pChannelsSignalingExchangeEffectfulAction,
+        },
         snark_effectful::P2pChannelsSnarkEffectfulAction,
         snark_job_commitment_effectful::P2pChannelsSnarkJobCommitmentEffectfulAction,
         streaming_rpc_effectful::P2pChannelsStreamingRpcEffectfulAction,
@@ -108,6 +111,7 @@ impl_into_global_action!(network::kad::P2pNetworkKademliaAction);
 impl_into_global_action!(network::pubsub::P2pNetworkPubsubAction);
 
 impl_into_global_action!(channels::P2pChannelsMessageReceivedAction);
+impl_into_global_action!(channels::signaling::discovery::P2pChannelsSignalingDiscoveryAction);
 impl_into_global_action!(channels::signaling::exchange::P2pChannelsSignalingExchangeAction);
 impl_into_global_action!(channels::best_tip::P2pChannelsBestTipAction);
 impl_into_global_action!(channels::transaction::P2pChannelsTransactionAction);
@@ -134,6 +138,9 @@ impl_into_global_action!(effectful p2p::P2pNetworkPnetEffectfulAction);
 impl_into_global_action!(effectful connection::incoming_effectful::P2pConnectionIncomingEffectfulAction);
 impl_into_global_action!(effectful connection::outgoing_effectful::P2pConnectionOutgoingEffectfulAction);
 impl_into_global_action!(effectful p2p::disconnection_effectful::P2pDisconnectionEffectfulAction);
+impl_into_global_action!(
+    effectful P2pChannelsSignalingDiscoveryEffectfulAction
+);
 impl_into_global_action!(effectful P2pChannelsSignalingExchangeEffectfulAction);
 impl_into_global_action!(effectful P2pChannelsBestTipEffectfulAction);
 impl_into_global_action!(effectful P2pChannelsStreamingRpcEffectfulAction);

p2p/src/channels/mod.rs

@@ -27,6 +27,7 @@ use binprot::{BinProtRead, BinProtWrite};
 use binprot_derive::{BinProtRead, BinProtWrite};
 use derive_more::From;
 use serde::{Deserialize, Serialize};
+use signaling::discovery::SignalingDiscoveryChannelMsg;
 use signaling::exchange::SignalingExchangeChannelMsg;
 use strum_macros::EnumIter;
 
@@ -40,6 +41,7 @@ use self::transaction::TransactionPropagationChannelMsg;
 #[derive(Serialize, Deserialize, EnumIter, Debug, Ord, PartialOrd, Eq, PartialEq, Clone, Copy)]
 #[repr(u8)]
 pub enum ChannelId {
+    SignalingDiscovery = 0,
     SignalingExchange = 1,
     BestTipPropagation = 2,
     TransactionPropagation = 3,
@@ -62,6 +64,7 @@ impl ChannelId {
 
     pub fn name(self) -> &'static str {
         match self {
+            Self::SignalingDiscovery => "signaling/discovery",
             Self::SignalingExchange => "signaling/exchange",
             Self::BestTipPropagation => "best_tip/propagation",
             Self::TransactionPropagation => "transaction/propagation",
@@ -74,6 +77,7 @@ impl ChannelId {
 
     pub fn supported_by_libp2p(self) -> bool {
         match self {
+            Self::SignalingDiscovery => false,
             Self::SignalingExchange => false,
             Self::BestTipPropagation => true,
             Self::TransactionPropagation => true,
@@ -87,7 +91,8 @@ impl ChannelId {
     pub fn max_msg_size(self) -> usize {
         match self {
             // TODO(binier): measure signaling message sizes
-            Self::SignalingExchange => 16 * 1024, // 16KB
+            Self::SignalingDiscovery => 16 * 1024, // 16KB
+            Self::SignalingExchange => 16 * 1024,  // 16KB
             // TODO(binier): reduce this value once we change message for best tip
             // propagation to just propagating consensus state with block hash.
             Self::BestTipPropagation => 32 * 1024 * 1024, // 32MB
@@ -129,6 +134,7 @@ impl MsgId {
 
 #[derive(BinProtWrite, BinProtRead, Serialize, Deserialize, From, Debug, Clone)]
 pub enum ChannelMsg {
+    SignalingDiscovery(SignalingDiscoveryChannelMsg),
     SignalingExchange(SignalingExchangeChannelMsg),
     BestTipPropagation(BestTipPropagationChannelMsg),
     TransactionPropagation(TransactionPropagationChannelMsg),
@@ -141,6 +147,7 @@ pub enum ChannelMsg {
 impl ChannelMsg {
     pub fn channel_id(&self) -> ChannelId {
         match self {
+            Self::SignalingDiscovery(_) => ChannelId::SignalingDiscovery,
             Self::SignalingExchange(_) => ChannelId::SignalingExchange,
             Self::BestTipPropagation(_) => ChannelId::BestTipPropagation,
             Self::TransactionPropagation(_) => ChannelId::TransactionPropagation,
@@ -156,6 +163,7 @@ impl ChannelMsg {
         W: std::io::Write,
     {
         match self {
+            Self::SignalingDiscovery(v) => v.binprot_write(w),
             Self::SignalingExchange(v) => v.binprot_write(w),
             Self::BestTipPropagation(v) => v.binprot_write(w),
             Self::TransactionPropagation(v) => v.binprot_write(w),
@@ -172,6 +180,9 @@ impl ChannelMsg {
         R: std::io::Read + ?Sized,
     {
         match id {
+            ChannelId::SignalingDiscovery => {
+                SignalingDiscoveryChannelMsg::binprot_read(r).map(|v| v.into())
+            }
             ChannelId::SignalingExchange => {
                 SignalingExchangeChannelMsg::binprot_read(r).map(|v| v.into())
             }
@@ -207,6 +218,11 @@ impl crate::P2pState {
         // exhaustive matching so that we don't miss any channels.
         for id in self.config.enabled_channels.iter().copied() {
             match id {
+                ChannelId::SignalingDiscovery => {
+                    dispatcher.push(
+                        signaling::discovery::P2pChannelsSignalingDiscoveryAction::Init { peer_id },
+                    );
+                }
                 ChannelId::SignalingExchange => {
                     dispatcher.push(
                         signaling::exchange::P2pChannelsSignalingExchangeAction::Init { peer_id },

p2p/src/channels/p2p_channels_actions.rs

@@ -9,6 +9,8 @@ use super::{
     rpc::P2pChannelsRpcAction,
     rpc_effectful::P2pChannelsRpcEffectfulAction,
     signaling::{
+        discovery::P2pChannelsSignalingDiscoveryAction,
+        discovery_effectful::P2pChannelsSignalingDiscoveryEffectfulAction,
         exchange::P2pChannelsSignalingExchangeAction,
         exchange_effectful::P2pChannelsSignalingExchangeEffectfulAction,
     },
@@ -26,6 +28,7 @@ use super::{
 #[derive(Serialize, Deserialize, Debug, Clone, openmina_core::ActionEvent)]
 pub enum P2pChannelsAction {
     MessageReceived(P2pChannelsMessageReceivedAction),
+    SignalingDiscovery(P2pChannelsSignalingDiscoveryAction),
     SignalingExchange(P2pChannelsSignalingExchangeAction),
     BestTip(P2pChannelsBestTipAction),
     Transaction(P2pChannelsTransactionAction),
@@ -37,6 +40,7 @@ pub enum P2pChannelsAction {
 
 #[derive(Serialize, Deserialize, Debug, Clone, openmina_core::ActionEvent)]
 pub enum P2pChannelsEffectfulAction {
+    SignalingDiscovery(P2pChannelsSignalingDiscoveryEffectfulAction),
     SignalingExchange(P2pChannelsSignalingExchangeEffectfulAction),
     BestTip(P2pChannelsBestTipEffectfulAction),
     Rpc(P2pChannelsRpcEffectfulAction),
@@ -50,6 +54,7 @@ impl P2pChannelsAction {
     pub fn peer_id(&self) -> Option<&PeerId> {
         match self {
             Self::MessageReceived(v) => Some(&v.peer_id),
+            Self::SignalingDiscovery(v) => Some(v.peer_id()),
             Self::SignalingExchange(v) => Some(v.peer_id()),
             Self::BestTip(v) => Some(v.peer_id()),
             Self::Transaction(v) => v.peer_id(),
@@ -65,6 +70,7 @@ impl redux::EnablingCondition<crate::P2pState> for P2pChannelsAction {
     fn is_enabled(&self, state: &crate::P2pState, time: redux::Timestamp) -> bool {
         match self {
             P2pChannelsAction::MessageReceived(a) => a.is_enabled(state, time),
+            P2pChannelsAction::SignalingDiscovery(a) => a.is_enabled(state, time),
             P2pChannelsAction::SignalingExchange(a) => a.is_enabled(state, time),
             P2pChannelsAction::Transaction(a) => a.is_enabled(state, time),
             P2pChannelsAction::BestTip(a) => a.is_enabled(state, time),
@@ -79,6 +85,7 @@ impl redux::EnablingCondition<crate::P2pState> for P2pChannelsAction {
 impl redux::EnablingCondition<crate::P2pState> for P2pChannelsEffectfulAction {
     fn is_enabled(&self, state: &crate::P2pState, time: redux::Timestamp) -> bool {
         match self {
+            P2pChannelsEffectfulAction::SignalingDiscovery(a) => a.is_enabled(state, time),
             P2pChannelsEffectfulAction::SignalingExchange(a) => a.is_enabled(state, time),
             P2pChannelsEffectfulAction::BestTip(a) => a.is_enabled(state, time),
             P2pChannelsEffectfulAction::Transaction(a) => a.is_enabled(state, time),