feat(p2p/webrtc): check chain id

Author: binier

core/src/chain_id.rs

@@ -5,8 +5,12 @@ use multihash::{Blake2b256, Hasher};
 use time::macros::format_description;
 use time::OffsetDateTime;
 
-use std::fmt::{self, Debug, Display, Formatter};
+use std::{
+    fmt::{self, Debug, Display, Formatter},
+    io::{Read, Write},
+};
 
+use binprot::{BinProtRead, BinProtWrite};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[derive(Clone, PartialEq, Eq)]
@@ -95,6 +99,23 @@ impl ChainId {
     }
 }
 
+impl BinProtWrite for ChainId {
+    fn binprot_write<W: Write>(&self, w: &mut W) -> std::io::Result<()> {
+        w.write_all(&self.0)
+    }
+}
+
+impl BinProtRead for ChainId {
+    fn binprot_read<R: Read + ?Sized>(r: &mut R) -> Result<Self, binprot::Error>
+    where
+        Self: Sized,
+    {
+        let mut bytes = [0; 32];
+        r.read_exact(&mut bytes)?;
+        Ok(Self(bytes))
+    }
+}
+
 impl Serialize for ChainId {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         serializer.serialize_str(&self.to_hex())

p2p/src/connection/incoming/mod.rs

@@ -33,6 +33,10 @@ impl P2pState {
         peer_id: PeerId,
         offer: &webrtc::Offer,
     ) -> Result<(), RejectionReason> {
+        if self.chain_id != offer.chain_id {
+            return Err(RejectionReason::ChainIdMismatch);
+        }
+
         if peer_id != offer.identity_pub_key.peer_id() {
             return Err(RejectionReason::PeerIdAndPublicKeyMismatch);
         }

p2p/src/connection/outgoing/p2p_connection_outgoing_reducer.rs

@@ -152,6 +152,7 @@ impl P2pConnectionOutgoingState {
                 Ok(())
             }
             P2pConnectionOutgoingAction::OfferSdpCreateSuccess { sdp, peer_id } => {
+                let chain_id = p2p_state.chain_id.clone();
                 let state = p2p_state
                     .outgoing_peer_connection_mut(&peer_id)
                     .ok_or("Missing peer connection for `P2pConnectionOutgoingAction::OfferSdpCreateSuccess`")?;
@@ -170,6 +171,7 @@ impl P2pConnectionOutgoingState {
 
                 let offer = Box::new(crate::webrtc::Offer {
                     sdp,
+                    chain_id,
                     identity_pub_key: p2p_state.config.identity_pub_key.clone(),
                     target_peer_id: peer_id,
                     // TODO(vlad9486): put real address

p2p/src/webrtc/signal.rs

@@ -1,5 +1,6 @@
 use binprot_derive::{BinProtRead, BinProtWrite};
 use derive_more::From;
+use openmina_core::ChainId;
 use serde::{Deserialize, Serialize};
 
 use crate::identity::{EncryptableType, PeerId, PublicKey};
@@ -9,6 +10,7 @@ use super::{ConnectionAuth, Host};
 #[derive(Serialize, Deserialize, Eq, PartialEq, Debug, Clone)]
 pub struct Offer {
     pub sdp: String,
+    pub chain_id: ChainId,
     /// Offerer's identity public key.
     pub identity_pub_key: PublicKey,
     /// Peer id that the offerer wants to connect to.
@@ -37,6 +39,8 @@ pub enum Signal {
 
 #[derive(Serialize, Deserialize, Eq, PartialEq, Debug, Clone, Copy, thiserror::Error)]
 pub enum RejectionReason {
+    #[error("peer is on a different chain")]
+    ChainIdMismatch,
     #[error("peer_id does not match peer's public key")]
     PeerIdAndPublicKeyMismatch,
     #[error("target peer_id is not local node's peer_id")]
@@ -83,6 +87,7 @@ impl Answer {
 impl RejectionReason {
     pub fn is_bad(&self) -> bool {
         match self {
+            Self::ChainIdMismatch => false,
             Self::PeerIdAndPublicKeyMismatch => true,
             Self::TargetPeerIdNotMe => true,
             Self::PeerCapacityFull => false,