Interoperability between rust-libp2p and py-libp2p focused on ping protocol

[paschal533]

Rust ↔ Py libp2p Interoperability: /ipfs/ping/1.0.0

The goal of this project is to establish interoperability between rust-libp2p and py-libp2p, with a focus on the core /ipfs/ping/1.0.0 protocol. It enables testing, validation, and cross-implementation compatibility between Rust and Python libp2p stacks.

🎯 Objective

Ensure that a py-libp2p node can connect to and exchange pings with a rust-libp2p node using:

• /ipfs/ping/1.0.0 protocol
• TCP/WebSocket transports
• Multiaddr-based peer discovery

🛠️ Tech Stack

Component	Technology
Python node	py-libp2p
Rust node	rust-libp2p
Protocol	/ipfs/ping/1.0.0
Transport	TCP / WebSockets
Format	32-byte raw echo ping

🔍 What We Are Testing

The following capabilities need to be tested or implemented in py-libp2p:

• Stream Multiplexer Compatibility
  • Ensure py-libp2p uses yamux (preferred) and negotiates correctly with Rust.
• Multistream Protocol Negotiation
  • Confirm that multistream-select works per libp2p spec and correctly selects /ipfs/ping/1.0.0.
• Ping Protocol Handler
  • Verify or implement the ability to send and read raw 32-byte payloads for /ipfs/ping/1.0.0.
• Transport Layer Support
  • Ensure TCP is fully supported; optionally test WebSocket compatibility if needed.
• Multiaddr Parsing
  • Dialing a multiaddr string like /ip4/127.0.0.1/tcp/15001/ws/p2p/<peer-id> must resolve correctly.
• Logging + Debug Info
  • Print peer ID, RTT, and payload hex for debugging.

Once these are in place, basic interop tests (e.g., successful echo and RTT) can be conducted reliably.

✅ Phase 0: Setup & Basic Ping

Rust (Listener)

• Create a basic rust-libp2p node with /ipfs/ping/1.0.0 handler
• Use TCP or WebSockets and print the peer ID + multiaddrs

Python (Dialer)

• Launch a minimal py-libp2p node
• Connect to Rust peer using the given multiaddr
• Dial /ipfs/ping/1.0.0 and send a 32-byte payload
• Validate echoed response

🔍 Phase 1: Interop Validation

Tests

• Confirm proper stream negotiation and protocol selection
• Measure round-trip ping latency
• Handle malformed payloads, dropped packets, and timeouts

Logs

• Output peer IDs, multiaddrs, payload hex, RTT metrics

📦 Directory Structure

interop-rust-py-libp2p/
├── rust_node/
│   └── ping-server.rs      # Rust ping listener
├── py_node/
│   └── ping_client.py      # Python dialer
├── scripts/
│   └── run_test.sh         # Launch both nodes and validate
├── README.md               # This file

🧪 Sample Multiaddr Flow

# Rust node prints:
Listening on /ip4/127.0.0.1/tcp/15001/p2p/12D3KooWRustNode
Python node dials:
/ip4/127.0.0.1/tcp/15001/p2p/12D3KooWRustNode

📊 Success Criteria

• Stream to /ipfs/ping/1.0.0 opens
• Ping echoed correctly and matches RTT expectations
• Compatible framing and protocol handling

🚀 Future Roadmap

Following successful ping interop:

• Add /libp2p/identify/1.0.0 test
• Enable NAT traversal via relay nodes
• Support QUIC and WebRTC transports
• Integrate with automated libp2p interop testbench