feat(core): add peer-record-interop feature for cross-implementation compatibility

Add optional `peer-record-interop` feature flag to enable standard libp2p
peer-record format for interoperability with Go and JavaScript implementations.

When enabled, uses:
- PAYLOAD_TYPE: [0x03, 0x01] (multicodec identifier)
- DOMAIN_SEP: "libp2p-peer-record"

When disabled (default), maintains backward compatibility with existing
Rust libp2p peer records using legacy constants:
- PAYLOAD_TYPE: "/libp2p/routing-state-record"
- DOMAIN_SEP: "libp2p-routing-state"

The legacy format is marked as deprecated to guide users toward the
standard format in future releases.

Changes:
- Add `peer-record-interop` feature flag to core/Cargo.toml
- Add conditional compilation for PAYLOAD_TYPE and DOMAIN_SEP constants
- Mark legacy constants as deprecated with migration guidance
- Update internal methods to handle both constant types (&[u8] vs &str)
- Gate interop tests to only run with feature enabled
- Update CHANGELOG and add inline documentation

Migration:
Users needing cross-implementation compatibility should add:
`libp2p-core = { version = "0.43.2", features = ["peer-record-interop"] }`

Author: r-zig

Cargo.lock

@@ -78,7 +78,7 @@ libp2p = { version = "0.56.1", path = "libp2p" }
 libp2p-allow-block-list = { version = "0.6.0", path = "misc/allow-block-list" }
 libp2p-autonat = { version = "0.15.0", path = "protocols/autonat" }
 libp2p-connection-limits = { version = "0.6.0", path = "misc/connection-limits" }
-libp2p-core = { version = "0.44.0", path = "core" }
+libp2p-core = { version = "0.43.2", path = "core" }
 libp2p-dcutr = { version = "0.14.0", path = "protocols/dcutr" }
 libp2p-dns = { version = "0.44.0", path = "transports/dns" }
 libp2p-floodsub = { version = "0.47.0", path = "protocols/floodsub" }

Cargo.toml

@@ -1,5 +1,13 @@
-## 0.44.0
-- Update `libp2p::core::peer_record` Fix peer record domain and payload type to match Go/JS implementations.
+## 0.43.2
+
+- Add `peer-record-interop` feature for cross-implementation compatibility with Go and JavaScript libp2p.
+  When enabled, uses standard libp2p-peer-record domain and payload type constants for interoperability.
+  When disabled (default), maintains backward compatibility with existing Rust libp2p peer records using legacy routing-state-record constants.
+  
+  To enable: Add `features = ["peer-record-interop"]` to your `libp2p-core` dependency.
+  
+  **Note:** Legacy constants are deprecated and will become opt-in in a future version.
+  
   See [PR 6205](https://github.com/libp2p/rust-libp2p/pull/6205).
 
 ## 0.43.1

core/CHANGELOG.md

@@ -3,7 +3,7 @@ name = "libp2p-core"
 edition.workspace = true
 rust-version = { workspace = true }
 description = "Core traits and structs of libp2p"
-version = "0.44.0"
+version = "0.43.2"
 authors = ["Parity Technologies <admin@parity.io>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"
@@ -39,6 +39,13 @@ libp2p-identity = { workspace = true, features = ["ed25519", "rand"] }
 [features]
 serde = ["multihash/serde-codec", "libp2p-identity/serde"]
 
+# Enable standard libp2p peer-record format for cross-implementation compatibility.
+# When enabled, peer records use the standard multicodec identifier (0x0301) and
+# "libp2p-peer-record" domain, ensuring compatibility with Go and JavaScript implementations.
+# When disabled (default), uses legacy "libp2p-routing-state" format for backward compatibility
+# with existing Rust libp2p deployments. The legacy format is deprecated.
+peer-record-interop = []
+
 # Passing arguments to the docsrs builder in order to properly document cfg's.
 # More information: https://docs.rs/about/builds#cross-compiling
 [package.metadata.docs.rs]

core/Cargo.toml

@@ -4,15 +4,46 @@ use web_time::SystemTime;
 
 use crate::{proto, signed_envelope, signed_envelope::SignedEnvelope, DecodeError, Multiaddr};
 
+// ## Cross-Implementation Compatibility
+//
+// By default, this implementation uses legacy constants for backward compatibility with existing
+// Rust libp2p peer records. To enable interoperability with Go and JavaScript libp2p implementations,
+// enable the `peer-record-interop` feature in your Cargo.toml:
+//
+// ```toml
+// libp2p-core = { version = "0.43.2", features = ["peer-record-interop"] }
+// ```
+//
+// The legacy format is deprecated and will become opt-in in a future release.
+
 // The type hint used to identify peer records in an Envelope.
-// Defined in https://github.com/multiformats/multicodec/blob/master/table.csv
-// with name "libp2p-peer-record"
+// With the `peer-record-interop` feature, uses the standard libp2p-peer-record
+// multicodec identifier as defined in https://github.com/multiformats/multicodec/blob/master/table.csv
+// Without the feature (default), uses the legacy routing-state-record format.
+#[cfg(feature = "peer-record-interop")]
 const PAYLOAD_TYPE: &[u8] = &[0x03, 0x01];
 
+#[cfg(not(feature = "peer-record-interop"))]
+#[deprecated(
+    since = "0.43.2",
+    note = "Legacy routing-state-record format. Enable the `peer-record-interop` feature for cross-implementation compatibility with Go/JS libp2p"
+)]
+const PAYLOAD_TYPE: &str = "/libp2p/routing-state-record";
+
 // The domain string used for peer records contained in a Envelope.
-// See https://github.com/libp2p/specs/blob/master/RFC/0002-signed-envelopes.md
+// With the `peer-record-interop` feature, uses the standard domain string
+// as defined in https://github.com/libp2p/specs/blob/master/RFC/0002-signed-envelopes.md
+// Without the feature (default), uses the legacy domain string.
+#[cfg(feature = "peer-record-interop")]
 const DOMAIN_SEP: &str = "libp2p-peer-record";
 
+#[cfg(not(feature = "peer-record-interop"))]
+#[deprecated(
+    since = "0.43.2",
+    note = "Legacy routing-state domain. Enable the `peer-record-interop` feature for cross-implementation compatibility with Go/JS libp2p"
+)]
+const DOMAIN_SEP: &str = "libp2p-routing-state";
+
 /// Represents a peer routing record.
 ///
 /// Peer records are designed to be distributable and carry a signature by being wrapped in a signed
@@ -35,11 +66,17 @@ impl PeerRecord {
     ///
     /// If this function succeeds, the [`SignedEnvelope`] contained a peer record with a valid
     /// signature and can hence be considered authenticated.
+    #[cfg_attr(not(feature = "peer-record-interop"), allow(deprecated))]
     pub fn from_signed_envelope(envelope: SignedEnvelope) -> Result<Self, FromEnvelopeError> {
         use quick_protobuf::MessageRead;
 
+        #[cfg(feature = "peer-record-interop")]
+        let payload_type = PAYLOAD_TYPE;
+        #[cfg(not(feature = "peer-record-interop"))]
+        let payload_type = PAYLOAD_TYPE.as_bytes();
+
         let (payload, signing_key) =
-            envelope.payload_and_signing_key(String::from(DOMAIN_SEP), PAYLOAD_TYPE)?;
+            envelope.payload_and_signing_key(String::from(DOMAIN_SEP), payload_type)?;
         let mut reader = BytesReader::from_bytes(payload);
         let record = proto::PeerRecord::from_reader(&mut reader, payload).map_err(DecodeError)?;
 
@@ -68,6 +105,7 @@ impl PeerRecord {
     ///
     /// This is the same key that is used for authenticating every libp2p connection of your
     /// application, i.e. what you use when setting up your [`crate::transport::Transport`].
+    #[cfg_attr(not(feature = "peer-record-interop"), allow(deprecated))]
     pub fn new(key: &Keypair, addresses: Vec<Multiaddr>) -> Result<Self, SigningError> {
         use quick_protobuf::MessageWrite;
 
@@ -98,10 +136,15 @@ impl PeerRecord {
             buf
         };
 
+        #[cfg(feature = "peer-record-interop")]
+        let payload_type = PAYLOAD_TYPE.to_vec();
+        #[cfg(not(feature = "peer-record-interop"))]
+        let payload_type = PAYLOAD_TYPE.as_bytes().to_vec();
+
         let envelope = SignedEnvelope::new(
             key,
             String::from(DOMAIN_SEP),
-            PAYLOAD_TYPE.to_vec(),
+            payload_type,
             payload,
         )?;
 
@@ -172,6 +215,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(not(feature = "peer-record-interop"), allow(deprecated))]
     fn mismatched_signature() {
         use quick_protobuf::MessageWrite;
 
@@ -199,10 +243,15 @@ mod tests {
                 buf
             };
 
+            #[cfg(feature = "peer-record-interop")]
+            let payload_type = PAYLOAD_TYPE.to_vec();
+            #[cfg(not(feature = "peer-record-interop"))]
+            let payload_type = PAYLOAD_TYPE.as_bytes().to_vec();
+
             SignedEnvelope::new(
                 &identity_b,
                 String::from(DOMAIN_SEP),
-                PAYLOAD_TYPE.to_vec(),
+                payload_type,
                 payload,
             )
             .unwrap()

core/src/peer_record.rs

@@ -1,4 +1,6 @@
-#[cfg(test)]
+// These tests verify interoperability with Go and JS libp2p implementations
+// and require the peer-record-interop feature to use the standard constants.
+#[cfg(all(test, feature = "peer-record-interop"))]
 mod tests {
     use libp2p_core::{PeerRecord, SignedEnvelope};