@libp2p/interop 4.0.2 → 6.0.0

package/src/dht/content-fetching.ts

@@ -13,7 +13,7 @@ const record = {
   value: uint8ArrayFromString('080012a60230820122300d06092a864886f70d01010105000382010f003082010a0282010100c2588f998971dac9e3eef76a311bf9159505aff69ea3b664c55a36aa28ee08de1127228a4d431bb9c0840240c75f6e98a0843a78d945491a3ea5e1f7cee2bc71383510db5290702383975b7bffae9fb40c84cc1220fb4a7db862fffb0de42f8fd8fb33a17deb20f30e2d0f194791fe69355a392f77df35f101e08a2fc95b2c018768938814fcb52482f899f5e90a1905e8abbcdbb1647ad80a5b0417e1ce8320d64197a6ba3848926375c63adebabdf6eb82109bcadfee13b62bf922bbb6f74c1a26c9bc6122d1436787e0e6de3c152b1959701092abef84599f73eaedb2fcef9f87293e1bbe8e0fef3f1a7fd2e8b94c7e633f88473644a63cb948e4d25c54490203010001', 'hex')
 }
 
-export function contentFetchingTests (factory: DaemonFactory) {
+export function contentFetchingTests (factory: DaemonFactory): void {
   const nodeTypes: NodeType[] = ['js', 'go']
 
   for (const typeA of nodeTypes) {
@@ -27,7 +27,7 @@ export function contentFetchingTests (factory: DaemonFactory) {
   }
 }
 
-function runContentFetchingTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions) {
+function runContentFetchingTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe('dht.contentFetching', () => {
     let daemons: Daemon[]
 
@@ -53,7 +53,7 @@ function runContentFetchingTests (factory: DaemonFactory, optionsA: SpawnOptions
     after(async function () {
       if (daemons != null) {
         await Promise.all(
-          daemons.map(async (daemon) => await daemon.stop())
+          daemons.map(async (daemon) => { await daemon.stop() })
         )
       }
     })

package/src/dht/content-routing.ts

@@ -6,7 +6,7 @@ import all from 'it-all'
 import type { Daemon, DaemonFactory, NodeType, SpawnOptions } from '../index.js'
 import type { IdentifyResult } from '@libp2p/daemon-client'
 
-export function contentRoutingTests (factory: DaemonFactory) {
+export function contentRoutingTests (factory: DaemonFactory): void {
   const nodeTypes: NodeType[] = ['js', 'go']
 
   for (const typeA of nodeTypes) {
@@ -25,7 +25,7 @@ export function contentRoutingTests (factory: DaemonFactory) {
   }
 }
 
-function runContentRoutingTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions) {
+function runContentRoutingTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe('dht.contentRouting', () => {
     let daemons: Daemon[]
     let identify: IdentifyResult[]
@@ -55,7 +55,7 @@ function runContentRoutingTests (factory: DaemonFactory, optionsA: SpawnOptions,
     after(async function () {
       if (daemons != null) {
         await Promise.all(
-          daemons.map(async (daemon) => await daemon.stop())
+          daemons.map(async (daemon) => { await daemon.stop() })
         )
       }
     })

package/src/dht/index.ts

@@ -3,8 +3,8 @@ import { contentFetchingTests } from './content-fetching.js'
 import { contentRoutingTests } from './content-routing.js'
 import { peerRoutingTests } from './peer-routing.js'
 
-export async function dhtTests (factory: DaemonFactory) {
-  await contentFetchingTests(factory)
-  await contentRoutingTests(factory)
-  await peerRoutingTests(factory)
+export async function dhtTests (factory: DaemonFactory): Promise<void> {
+  contentFetchingTests(factory)
+  contentRoutingTests(factory)
+  peerRoutingTests(factory)
 }

package/src/dht/peer-routing.ts

@@ -5,7 +5,7 @@ import type { Daemon, DaemonFactory, NodeType, SpawnOptions } from '../index.js'
 import pRetry from 'p-retry'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 
-export function peerRoutingTests (factory: DaemonFactory) {
+export function peerRoutingTests (factory: DaemonFactory): void {
   const nodeTypes: NodeType[] = ['js', 'go']
 
   for (const typeA of nodeTypes) {
@@ -19,7 +19,7 @@ export function peerRoutingTests (factory: DaemonFactory) {
   }
 }
 
-function runPeerRoutingTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions) {
+function runPeerRoutingTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe('dht.peerRouting', () => {
     let daemons: Daemon[]
 
@@ -38,7 +38,7 @@ function runPeerRoutingTests (factory: DaemonFactory, optionsA: SpawnOptions, op
     after(async function () {
       if (daemons != null) {
         await Promise.all(
-          daemons.map(async (daemon) => await daemon.stop())
+          daemons.map(async (daemon) => { await daemon.stop() })
         )
       }
     })

package/src/index.ts

@@ -2,6 +2,7 @@ import { connectTests } from './connect.js'
 import { dhtTests } from './dht/index.js'
 import { pubsubTests } from './pubsub/index.js'
 import { streamTests } from './streams/index.js'
+import { relayTests } from './relay/index.js'
 import type { DaemonClient } from '@libp2p/daemon-client'
 
 export interface Daemon {
@@ -22,14 +23,19 @@ export interface SpawnOptions {
   pubsub?: boolean
   pubsubRouter?: PubSubRouter
   muxer?: Muxer
+  relay?: boolean
+  // the node will not listen on any
+  // addresses if true
+  noListen?: boolean
 }
 
 export interface DaemonFactory {
   spawn: (options: SpawnOptions) => Promise<Daemon>
 }
 
-export async function interopTests (factory: DaemonFactory) {
-  await connectTests(factory)
+export async function interopTests (factory: DaemonFactory): Promise<void> {
+  connectTests(factory)
+  relayTests(factory)
   await dhtTests(factory)
   await pubsubTests(factory)
   await streamTests(factory)
@@ -39,5 +45,6 @@ export {
   connectTests as connectInteropTests,
   dhtTests as dhtInteropTests,
   pubsubTests as pubsubInteropTests,
-  streamTests as streamInteropTests
+  streamTests as streamInteropTests,
+  relayTests as relayInteropTests
 }

package/src/pubsub/floodsub.ts

@@ -5,7 +5,7 @@ import type { Daemon, DaemonFactory, NodeType, SpawnOptions } from '../index.js'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import first from 'it-first'
 
-export function floodsubTests (factory: DaemonFactory) {
+export function floodsubTests (factory: DaemonFactory): void {
   const nodeTypes: NodeType[] = ['js', 'go']
 
   for (const typeA of nodeTypes) {
@@ -19,7 +19,7 @@ export function floodsubTests (factory: DaemonFactory) {
   }
 }
 
-function runFloodsubTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions) {
+function runFloodsubTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe('pubsub.floodSub', () => {
     let daemons: Daemon[]
 
@@ -32,15 +32,16 @@ function runFloodsubTests (factory: DaemonFactory, optionsA: SpawnOptions, optio
         factory.spawn(optionsB)
       ])
 
-      const identify1 = await daemons[1].client.identify()
-      await daemons[0].client.connect(identify1.peerId, identify1.addrs)
+      const [peerA, peerB] = daemons
+      const identifyB = await peerB.client.identify()
+      await peerA.client.connect(identifyB.peerId, identifyB.addrs)
     })
 
     // Stop daemons
     after(async function () {
       if (daemons != null) {
         await Promise.all(
-          daemons.map(async (daemon) => await daemon.stop())
+          daemons.map(async (daemon) => { await daemon.stop() })
         )
       }
     })
@@ -48,19 +49,20 @@ function runFloodsubTests (factory: DaemonFactory, optionsA: SpawnOptions, optio
     it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
       const topic = 'test-topic'
       const data = uint8ArrayFromString('test-data')
+      const [peerA, peerB] = daemons
 
-      const subscribeIterator = daemons[1].client.pubsub.subscribe(topic)
-      const subscriber = async () => {
+      const subscribeIterator = peerB.client.pubsub.subscribe(topic)
+      const subscriber = async (): Promise<void> => {
         const message = await first(subscribeIterator)
 
         expect(message).to.exist()
         expect(message).to.have.property('data').that.equalBytes(data)
       }
 
-      const publisher = async () => {
+      const publisher = async (): Promise<void> => {
         // wait for subscription stream
         await new Promise(resolve => setTimeout(resolve, 800))
-        await daemons[0].client.pubsub.publish(topic, data)
+        await peerA.client.pubsub.publish(topic, data)
       }
 
       return await Promise.all([

package/src/pubsub/gossipsub.ts

@@ -5,7 +5,7 @@ import type { Daemon, DaemonFactory, NodeType, SpawnOptions } from '../index.js'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import first from 'it-first'
 
-export function gossipsubTests (factory: DaemonFactory) {
+export function gossipsubTests (factory: DaemonFactory): void {
   const nodeTypes: NodeType[] = ['js', 'go']
 
   for (const typeA of nodeTypes) {
@@ -19,7 +19,7 @@ export function gossipsubTests (factory: DaemonFactory) {
   }
 }
 
-function runGossipsubTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions) {
+function runGossipsubTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe('pubsub.gossipsub', () => {
     let daemons: Daemon[]
 
@@ -40,7 +40,7 @@ function runGossipsubTests (factory: DaemonFactory, optionsA: SpawnOptions, opti
     after(async function () {
       if (daemons != null) {
         await Promise.all(
-          daemons.map(async (daemon) => await daemon.stop())
+          daemons.map(async daemon => { await daemon.stop() })
         )
       }
     })
@@ -50,14 +50,14 @@ function runGossipsubTests (factory: DaemonFactory, optionsA: SpawnOptions, opti
       const data = uint8ArrayFromString('test-data')
 
       const subscribeIterator = daemons[1].client.pubsub.subscribe(topic)
-      const subscriber = async () => {
+      const subscriber = async (): Promise<void> => {
         const message = await first(subscribeIterator)
 
         expect(message).to.exist()
         expect(message).to.have.property('data').that.equalBytes(data)
       }
 
-      const publisher = async () => {
+      const publisher = async (): Promise<void> => {
         // wait for subscription stream
         await new Promise(resolve => setTimeout(resolve, 800))
         await daemons[0].client.pubsub.publish(topic, data)

package/src/pubsub/hybrid.ts

@@ -5,7 +5,7 @@ import type { Daemon, DaemonFactory, NodeType, SpawnOptions } from '../index.js'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import first from 'it-first'
 
-export function hybridTests (factory: DaemonFactory) {
+export function hybridTests (factory: DaemonFactory): void {
   const nodeTypes: NodeType[] = ['js', 'go']
 
   for (const typeA of nodeTypes) {
@@ -19,7 +19,7 @@ export function hybridTests (factory: DaemonFactory) {
   }
 }
 
-function runHybridTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions) {
+function runHybridTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe('pubsub.hybrid', () => {
     let daemons: Daemon[]
 
@@ -40,7 +40,7 @@ function runHybridTests (factory: DaemonFactory, optionsA: SpawnOptions, options
     after(async function () {
       if (daemons != null) {
         await Promise.all(
-          daemons.map(async (daemon) => await daemon.stop())
+          daemons.map(async (daemon) => { await daemon.stop() })
         )
       }
     })
@@ -50,14 +50,14 @@ function runHybridTests (factory: DaemonFactory, optionsA: SpawnOptions, options
       const data = uint8ArrayFromString('test-data')
 
       const subscribeIterator = daemons[1].client.pubsub.subscribe(topic)
-      const subscriber = async () => {
+      const subscriber = async (): Promise<void> => {
         const message = await first(subscribeIterator)
 
         expect(message).to.exist()
         expect(message).to.have.property('data').that.equalBytes(data)
       }
 
-      const publisher = async () => {
+      const publisher = async (): Promise<void> => {
         // wait for subscription stream
         await new Promise(resolve => setTimeout(resolve, 800))
         await daemons[0].client.pubsub.publish(topic, data)

package/src/pubsub/index.ts

@@ -3,8 +3,8 @@ import { floodsubTests } from './floodsub.js'
 import { gossipsubTests } from './gossipsub.js'
 import { hybridTests } from './hybrid.js'
 
-export async function pubsubTests (factory: DaemonFactory) {
-  await floodsubTests(factory)
-  await gossipsubTests(factory)
-  await hybridTests(factory)
+export async function pubsubTests (factory: DaemonFactory): Promise<void> {
+  floodsubTests(factory)
+  gossipsubTests(factory)
+  hybridTests(factory)
 }

package/src/relay/index.ts

@@ -0,0 +1,76 @@
+import { Multiaddr, multiaddr } from '@multiformats/multiaddr'
+import { expect } from 'aegir/chai'
+import type { Daemon, DaemonFactory, NodeType, SpawnOptions } from '../index.js'
+import { Status } from './pb/index.js'
+import { echoHandler, reserve } from './util.js'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import type { IdentifyResult } from '@libp2p/daemon-client'
+import { handshake } from 'it-handshake'
+
+export function relayTests (factory: DaemonFactory): void {
+  const t: NodeType[] = ['go', 'js']
+  t.forEach(a => { t.forEach(b => { t.forEach(r => { relayTest(factory, a, b, r) }) }) })
+}
+
+function relayTest (factory: DaemonFactory, aType: NodeType, bType: NodeType, relayType: NodeType): void {
+  describe(`${aType} to ${bType} over relay ${relayType}`, () => {
+    const opts: SpawnOptions[] = [
+      { type: aType, noise: true, noListen: true },
+      { type: bType, noise: true, noListen: true },
+      { type: relayType, noise: true, relay: true }
+    ]
+
+    let aNode: Daemon
+    let bNode: Daemon
+    let relay: Daemon
+    let bId: IdentifyResult
+    let relayId: IdentifyResult
+    let bAddrViaRelay: Multiaddr
+
+    beforeEach(async function () {
+      this.timeout(20 * 1000)
+      ;[aNode, bNode, relay] = await Promise.all(opts.map(async o => await factory.spawn(o)))
+      ;[bId, relayId] = await Promise.all([bNode, relay].map(async d => await d.client.identify()))
+
+      // construct a relay address
+      bAddrViaRelay = multiaddr(`${relayId.addrs[0].toString()}/p2p/${relayId.peerId.toString()}/p2p-circuit/p2p/${bId.peerId.toString()}`)
+
+      // connect b to the relay
+      await bNode.client.connect(relayId.peerId, relayId.addrs)
+    })
+
+    afterEach(async function () {
+      await Promise.all([aNode, bNode, relay].map(async d => { await d.stop() }))
+    })
+
+    it('connects', async () => {
+      // b makes reservation on relay
+      const reserveResponse = await reserve(bNode, relayId.peerId)
+      expect(reserveResponse.status).to.eq(Status.OK)
+
+      // a dials b through relay
+      await aNode.client.connect(bId.peerId, [bAddrViaRelay])
+      await new Promise(resolve => setTimeout(resolve, 500))
+      const connectedPeers = await aNode.client.listPeers()
+      expect(connectedPeers.filter(p => p.equals(bId.peerId))).to.have.length(1)
+
+      // run an echo test
+      await bNode.client.registerStreamHandler(echoHandler.protocol, echoHandler.handler)
+      const stream = await aNode.client.openStream(bId.peerId, echoHandler.protocol)
+
+      // send some data, read the response
+      const input = uint8ArrayFromString('test')
+      const shake = handshake(stream)
+      shake.write(input)
+      const output = await shake.read()
+
+      expect(output?.subarray()).to.deep.equal(input)
+    })
+
+    it('fails to connect without a reservation', async () => {
+      // a dials b through relay
+      await expect(aNode.client.connect(bId.peerId, [bAddrViaRelay])).to.eventually.be.rejected
+        .with.property('message').that.matches(/NO_RESERVATION/)
+    })
+  })
+}

package/src/relay/pb/index.proto

@@ -0,0 +1,67 @@
+syntax = "proto3";
+
+message HopMessage {
+  enum Type {
+    RESERVE = 0;
+    CONNECT = 1;
+    STATUS = 2;
+  }
+
+  // the presence of this field is enforced at application level
+  optional Type type = 1;
+
+  optional Peer peer = 2;
+  optional Reservation reservation = 3;
+  optional Limit limit = 4;
+
+  optional Status status = 5;
+}
+
+message StopMessage {
+  enum Type {
+    CONNECT = 0;
+    STATUS = 1;
+  }
+
+  // the presence of this field is enforced at application level
+  optional Type type = 1;
+
+  optional Peer peer = 2;
+  optional Limit limit = 3;
+
+  optional Status status = 4;
+}
+
+message Peer {
+  bytes id = 1;
+  repeated bytes addrs = 2;
+}
+
+message Reservation {
+  uint64 expire = 1; // Unix expiration time (UTC)
+  repeated bytes addrs = 2;   // relay addrs for reserving peer
+  optional bytes voucher = 3; // reservation voucher
+}
+
+message Limit {
+  optional uint32 duration = 1; // seconds
+  optional uint64 data = 2;     // bytes
+}
+
+enum Status {
+  UNUSED = 0;
+  OK                      = 100;
+  RESERVATION_REFUSED     = 200;
+  RESOURCE_LIMIT_EXCEEDED = 201;
+  PERMISSION_DENIED       = 202;
+  CONNECTION_FAILED       = 203;
+  NO_RESERVATION          = 204;
+  MALFORMED_MESSAGE       = 400;
+  UNEXPECTED_MESSAGE      = 401;
+}
+
+message ReservationVoucher {
+  bytes relay = 1;
+  bytes peer = 2;
+  uint64 expiration = 3;
+}