WIP: Add interoperability test for py-libp2p and js-libp2p

tests/interop/js_libp2p/README.md

@@ -0,0 +1,81 @@
+# py-libp2p and js-libp2p Interoperability Tests
+
+This repository contains interoperability tests for py-libp2p and js-libp2p using the /ipfs/ping/1.0.0 protocol. The goal is to verify compatibility in stream multiplexing, protocol negotiation, ping handling, transport layer, and multiaddr parsing.
+
+## Directory Structure
+
+- js_node/ping.js: JavaScript implementation of a ping server and client using libp2p.
+- py_node/ping.py: Python implementation of a ping server and client using py-libp2p.
+- scripts/run_test.sh: Shell script to automate running the server and client for testing.
+- README.md: This file.
+
+## Prerequisites
+
+- Python 3.8+ with `py-libp2p` and dependencies (`pip install libp2p trio cryptography multiaddr`).
+- Node.js 16+ with `libp2p` dependencies (`npm install @libp2p/core @libp2p/tcp @chainsafe/libp2p-noise @chainsafe/libp2p-yamux @libp2p/ping @libp2p/identify @multiformats/multiaddr`).
+- Bash shell for running `run_test.sh`.
+
+## Running Tests
+
+1. Change directory:
+
+```
+cd tests/interop/js_libp2p
+```
+
+2. Install dependencies:
+
+```
+For JavaScript: cd js_node && npm install && cd ...
+```
+
+3. Run the automated test:
+
+For Linux and Mac users:
+
+```
+chmod +x scripts/run_test.sh
+./scripts/run_test.sh
+```
+
+For Windows users:
+
+```
+.\scripts\run_test.ps1
+```
+
+This starts the Python server on port 8000 and runs the JavaScript client to send 5 pings.
+
+## Debugging
+
+- Logs are saved in py_node/py_server.log and js_node/js_client.log.
+- Check for:
+  - Successful connection establishment.
+  - Protocol negotiation (/ipfs/ping/1.0.0).
+  - 32-byte payload echo in server logs.
+  - RTT and payload hex in client logs.
+
+## Test Plan
+
+### The test verifies:
+
+- Stream Multiplexer Compatibility: Yamux is used and negotiates correctly.
+- Multistream Protocol Negotiation: /ipfs/ping/1.0.0 is selected via multistream-select.
+- Ping Protocol Handler: Handles 32-byte payloads per the libp2p ping spec.
+- Transport Layer Support: TCP is used; WebSocket support is optional.
+- Multiaddr Parsing: Correctly resolves multiaddr strings.
+- Logging: Includes peer ID, RTT, and payload hex for debugging.
+
+## Current Status
+
+### Working:
+
+- TCP transport and Noise encryption are functional.
+- Yamux multiplexing is implemented in both nodes.
+- Multiaddr parsing works correctly.
+- Logging provides detailed debug information.
+
+## Not Working:
+
+- Ping protocol handler fails to complete pings (JS client reports "operation aborted").
+- Potential issues with stream handling or protocol negotiation.

tests/interop/js_libp2p/js_node/.gitIgnore

@@ -0,0 +1,5 @@
+/node_modules
+/package-lock.json
+/dist
+.log
+.github

tests/interop/js_libp2p/js_node/README.md

@@ -0,0 +1,53 @@
+# @libp2p/example-chat <!-- omit in toc -->
+
+[![libp2p.io](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](http://libp2p.io/)
+[![Discuss](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg?style=flat-square)](https://discuss.libp2p.io)
+[![codecov](https://img.shields.io/codecov/c/github/libp2p/js-libp2p-examples.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-examples)
+[![CI](https://img.shields.io/github/actions/workflow/status/libp2p/js-libp2p-examples/ci.yml?branch=main&style=flat-square)](https://github.com/libp2p/js-libp2p-examples/actions/workflows/ci.yml?query=branch%3Amain)
+
+> An example chat app using libp2p
+
+## Table of contents <!-- omit in toc -->
+
+- [Setup](#setup)
+- [Running](#running)
+- [Need help?](#need-help)
+- [License](#license)
+- [Contribution](#contribution)
+
+## Setup
+
+1. Install example dependencies
+   ```console
+   $ npm install
+   ```
+1. Open 2 terminal windows in the `./src` directory.
+
+## Running
+
+1. Run the listener in window 1, `node listener.js`
+1. Run the dialer in window 2, `node dialer.js`
+1. Wait until the two peers discover each other
+1. Type a message in either window and hit *enter*
+1. Tell yourself secrets to your hearts content!
+
+## Need help?
+
+- Read the [js-libp2p documentation](https://github.com/libp2p/js-libp2p/tree/main/doc)
+- Check out the [js-libp2p API docs](https://libp2p.github.io/js-libp2p/)
+- Check out the [general libp2p documentation](https://docs.libp2p.io) for tips, how-tos and more
+- Read the [libp2p specs](https://github.com/libp2p/specs)
+- Ask a question on the [js-libp2p discussion board](https://github.com/libp2p/js-libp2p/discussions)
+
+## License
+
+Licensed under either of
+
+- Apache 2.0, ([LICENSE-APACHE](LICENSE-APACHE) / <http://www.apache.org/licenses/LICENSE-2.0>)
+- MIT ([LICENSE-MIT](LICENSE-MIT) / <http://opensource.org/licenses/MIT>)
+
+## Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.

tests/interop/js_libp2p/js_node/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@libp2p/example-chat",
+  "version": "0.0.0",
+  "description": "An example chat app using libp2p",
+  "license": "Apache-2.0 OR MIT",
+  "homepage": "https://github.com/libp2p/js-libp2p-example-chat#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/libp2p/js-libp2p-examples.git"
+  },
+  "bugs": {
+    "url": "https://github.com/libp2p/js-libp2p-examples/issues"
+  },
+  "type": "module",
+  "scripts": {
+    "test": "test-node-example test/*"
+  },
+  "dependencies": {
+    "@chainsafe/libp2p-noise": "^16.0.0",
+    "@chainsafe/libp2p-yamux": "^7.0.0",
+    "@libp2p/identify": "^3.0.33",
+    "@libp2p/mdns": "^11.0.1",
+    "@libp2p/ping": "^2.0.33",
+    "@libp2p/tcp": "^10.0.0",
+    "@libp2p/websockets": "^9.0.0",
+    "@multiformats/multiaddr": "^12.3.1",
+    "@nodeutils/defaults-deep": "^1.1.0",
+    "it-length-prefixed": "^10.0.1",
+    "it-map": "^3.0.3",
+    "it-pipe": "^3.0.1",
+    "libp2p": "^2.0.0",
+    "p-defer": "^4.0.0",
+    "uint8arrays": "^5.1.0"
+  },
+  "devDependencies": {
+    "test-ipfs-example": "^1.1.0"
+  },
+  "private": true
+}

tests/interop/js_libp2p/js_node/src/ping.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+
+import { createLibp2p } from 'libp2p'
+import { tcp } from '@libp2p/tcp'
+import { noise } from '@chainsafe/libp2p-noise'
+import { yamux } from '@chainsafe/libp2p-yamux'
+import { ping } from '@libp2p/ping'
+import { identify } from '@libp2p/identify'
+import { multiaddr } from '@multiformats/multiaddr'
+
+async function createNode() {
+  return await createLibp2p({
+    addresses: {
+      listen: ['/ip4/0.0.0.0/tcp/0']
+    },
+    transports: [
+      tcp()
+    ],
+    connectionEncrypters: [
+      noise()
+    ],
+    streamMuxers: [
+      yamux()
+    ],
+    services: {
+      // Use ipfs prefix to match py-libp2p example
+      ping: ping({
+        protocolPrefix: 'ipfs',
+        maxInboundStreams: 32,
+        maxOutboundStreams: 64,
+        timeout: 30000
+      }),
+      identify: identify()
+    },
+    connectionManager: {
+      minConnections: 0,
+      maxConnections: 100,
+      dialTimeout: 30000
+    }
+  })
+}
+
+async function runServer() {
+  console.log('🚀 Starting js-libp2p ping server...')
+
+  const node = await createNode()
+  await node.start()
+
+  console.log('✅ Server started!')
+  console.log(`📋 Peer ID: ${node.peerId.toString()}`)
+  console.log('📍 Listening addresses:')
+
+  node.getMultiaddrs().forEach(addr => {
+    console.log(`   ${addr.toString()}`)
+  })
+
+  // Listen for connections
+  node.addEventListener('peer:connect', (evt) => {
+    console.log(`🔗 Peer connected: ${evt.detail.toString()}`)
+  })
+
+  node.addEventListener('peer:disconnect', (evt) => {
+    console.log(`❌ Peer disconnected: ${evt.detail.toString()}`)
+  })
+
+  console.log('\n🎧 Server ready for ping requests...')
+  console.log('Press Ctrl+C to exit')
+
+  // Graceful shutdown
+  process.on('SIGINT', async () => {
+    console.log('\n🛑 Shutting down...')
+    await node.stop()
+    process.exit(0)
+  })
+
+  // Keep alive
+  while (true) {
+    await new Promise(resolve => setTimeout(resolve, 1000))
+  }
+}
+
+async function runClient(targetAddr, count = 5) {
+  console.log('🚀 Starting js-libp2p ping client...')
+
+  const node = await createNode()
+  await node.start()
+
+  console.log(`📋 Our Peer ID: ${node.peerId.toString()}`)
+  console.log(`🎯 Target: ${targetAddr}`)
+
+  try {
+    const ma = multiaddr(targetAddr)
+    const targetPeerId = ma.getPeerId()
+
+    if (!targetPeerId) {
+      throw new Error('Could not extract peer ID from multiaddr')
+    }
+
+    console.log(`🎯 Target Peer ID: ${targetPeerId}`)
+    console.log('🔗 Connecting to peer...')
+
+    const connection = await node.dial(ma)
+    console.log('✅ Connection established!')
+    console.log(`🔗 Connected to: ${connection.remotePeer.toString()}`)
+
+    // Add a small delay to let the connection fully establish
+    await new Promise(resolve => setTimeout(resolve, 1000))
+
+    const rtts = []
+
+    for (let i = 1; i <= count; i++) {
+      try {
+        console.log(`\n🏓 Sending ping ${i}/${count}...`);
+        console.log('[DEBUG] Attempting to open ping stream with protocol: /ipfs/ping/1.0.0');
+        const start = Date.now()
+
+        const stream = await connection.newStream(['/ipfs/ping/1.0.0']).catch(err => {
+          console.error(`[ERROR] Failed to open ping stream: ${err.message}`);
+          throw err;
+        });
+        console.log('[DEBUG] Ping stream opened successfully');
+
+        const latency = await Promise.race([
+          node.services.ping.ping(connection.remotePeer),
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('Ping timeout')), 30000) // Increased timeout
+          )
+        ]).catch(err => {
+          console.error(`[ERROR] Ping ${i} error: ${err.message}`);
+          throw err;
+        });
+
+        const rtt = Date.now() - start;
+
+        rtts.push(latency)
+        console.log(`✅ Ping ${i} successful!`)
+        console.log(`   Reported latency: ${latency}ms`)
+        console.log(`   Measured RTT: ${rtt}ms`)
+
+        if (i < count) {
+          await new Promise(resolve => setTimeout(resolve, 1000))
+        }
+      } catch (error) {
+        console.error(`❌ Ping ${i} failed:`, error.message)
+        // Try to continue with other pings
+      }
+    }
+
+    // Stats
+    if (rtts.length > 0) {
+      const avg = rtts.reduce((a, b) => a + b, 0) / rtts.length
+      const min = Math.min(...rtts)
+      const max = Math.max(...rtts)
+
+      console.log(`\n📊 Ping Statistics:`)
+      console.log(`   Packets: Sent=${count}, Received=${rtts.length}, Lost=${count - rtts.length}`)
+      console.log(`   Latency: min=${min}ms, avg=${avg.toFixed(2)}ms, max=${max}ms`)
+    } else {
+      console.log(`\n📊 All pings failed (${count} attempts)`)
+    }
+
+  } catch (error) {
+    console.error('❌ Client error:', error.message)
+    console.error('Stack:', error.stack)
+    process.exit(1)
+  } finally {
+    await node.stop()
+    console.log('\n⏹️  Client stopped')
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2)
+
+  if (args.length === 0) {
+    console.log('Usage:')
+    console.log('  node ping.js server                    # Start ping server')
+    console.log('  node ping.js client <multiaddr> [count]  # Ping a peer')
+    console.log('')
+    console.log('Examples:')
+    console.log('  node ping.js server')
+    console.log('  node ping.js client /ip4/127.0.0.1/tcp/12345/p2p/12D3Ko... 5')
+    process.exit(1)
+  }
+
+  const mode = args[0]
+
+  if (mode === 'server') {
+    await runServer()
+  } else if (mode === 'client') {
+    if (args.length < 2) {
+      console.error('❌ Client mode requires target multiaddr')
+      process.exit(1)
+    }
+    const targetAddr = args[1]
+    const count = parseInt(args[2]) || 5
+    await runClient(targetAddr, count)
+  } else {
+    console.error('❌ Invalid mode. Use "server" or "client"')
+    process.exit(1)
+  }
+}
+
+main().catch(console.error)