Add borsh support for PeerMessage::DistanceVector

chain/network/src/network_protocol/borsh.rs

@@ -82,6 +82,19 @@ pub(super) struct RoutingTableUpdate {
     pub accounts: Vec<AnnounceAccount>,
 }
 
+#[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone, Debug)]
+pub struct AdvertisedPeerDistance {
+    pub destination: PeerId,
+    pub distance: u32,
+}
+
+#[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone, Debug)]
+pub(super) struct DistanceVector {
+    pub root: PeerId,
+    pub distances: Vec<AdvertisedPeerDistance>,
+    pub edges: Vec<Edge>,
+}
+
 #[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone, Debug)]
 pub enum HandshakeFailureReason {
     ProtocolVersionMismatch { version: u32, oldest_supported_version: u32 },
@@ -139,6 +152,8 @@ pub(super) enum PeerMessage {
     _EpochSyncFinalizationRequest,
     _EpochSyncFinalizationResponse,
     _RoutingTableSyncV2,
+
+    DistanceVector(DistanceVector),
 }
 #[cfg(target_arch = "x86_64")] // Non-x86_64 doesn't match this requirement yet but it's not bad as it's not production-ready
 const _: () = assert!(std::mem::size_of::<PeerMessage>() <= 1144, "PeerMessage > 1144 bytes");

chain/network/src/network_protocol/borsh_conv.rs

@@ -90,6 +90,42 @@ impl From<mem::RoutingTableUpdate> for net::RoutingTableUpdate {
 
 //////////////////////////////////////////
 
+impl From<net::AdvertisedPeerDistance> for mem::AdvertisedPeerDistance {
+    fn from(x: net::AdvertisedPeerDistance) -> Self {
+        Self { destination: x.destination, distance: x.distance }
+    }
+}
+
+impl From<mem::AdvertisedPeerDistance> for net::AdvertisedPeerDistance {
+    fn from(x: mem::AdvertisedPeerDistance) -> Self {
+        Self { destination: x.destination, distance: x.distance }
+    }
+}
+
+//////////////////////////////////////////
+
+impl From<net::DistanceVector> for mem::DistanceVector {
+    fn from(x: net::DistanceVector) -> Self {
+        Self {
+            root: x.root,
+            distances: x.distances.into_iter().map(|y| y.into()).collect(),
+            edges: x.edges,
+        }
+    }
+}
+
+impl From<mem::DistanceVector> for net::DistanceVector {
+    fn from(x: mem::DistanceVector) -> Self {
+        Self {
+            root: x.root,
+            distances: x.distances.into_iter().map(|y| y.into()).collect(),
+            edges: x.edges,
+        }
+    }
+}
+
+//////////////////////////////////////////
+
 #[derive(thiserror::Error, Debug)]
 pub enum ParsePeerMessageError {
     #[error("HandshakeV2 is deprecated")]
@@ -156,6 +192,7 @@ impl TryFrom<&net::PeerMessage> for mem::PeerMessage {
             net::PeerMessage::_RoutingTableSyncV2 => {
                 return Err(Self::Error::DeprecatedRoutingTableSyncV2)
             }
+            net::PeerMessage::DistanceVector(dv) => mem::PeerMessage::DistanceVector(dv.into()),
         })
     }
 }
@@ -177,9 +214,7 @@ impl From<&mem::PeerMessage> for net::PeerMessage {
                 net::PeerMessage::SyncRoutingTable(rtu.into())
             }
             mem::PeerMessage::RequestUpdateNonce(e) => net::PeerMessage::RequestUpdateNonce(e),
-            mem::PeerMessage::DistanceVector(_) => {
-                panic!("DistanceVector is not supported in Borsh encoding")
-            }
+            mem::PeerMessage::DistanceVector(dv) => net::PeerMessage::DistanceVector(dv.into()),
 
             // This message is not supported, we translate it to an empty RoutingTableUpdate.
             mem::PeerMessage::SyncAccountsData(_) => {