@libp2p/interface-compliance-tests 1.1.15 → 1.1.18

package/src/mocks/connection-encrypter.ts

@@ -0,0 +1,110 @@
+import { peerIdFromBytes } from '@libp2p/peer-id'
+import { handshake } from 'it-handshake'
+import { duplexPair } from 'it-pair/duplex'
+import { pipe } from 'it-pipe'
+import { UnexpectedPeerError } from '@libp2p/interfaces/connection-encrypter/errors'
+import { Multiaddr } from '@multiformats/multiaddr'
+import type { ConnectionEncrypter } from '@libp2p/interfaces/connection-encrypter'
+import type { Transform, Source } from 'it-stream-types'
+
+// A basic transform that does nothing to the data
+const transform = (): Transform<Uint8Array, Uint8Array> => {
+  return (source: Source<Uint8Array>) => (async function * () {
+    for await (const chunk of source) {
+      yield chunk
+    }
+  })()
+}
+
+export function mockConnectionEncrypter () {
+  const encrypter: ConnectionEncrypter = {
+    protocol: 'insecure',
+    secureInbound: async (localPeer, duplex, expectedPeer) => {
+      // 1. Perform a basic handshake.
+      const shake = handshake(duplex)
+      shake.write(localPeer.toBytes())
+      const remoteId = await shake.read()
+
+      if (remoteId == null) {
+        throw new Error('Could not read remote ID')
+      }
+
+      const remotePeer = peerIdFromBytes(remoteId.slice())
+      shake.rest()
+
+      if (expectedPeer != null && !expectedPeer.equals(remotePeer)) {
+        throw new UnexpectedPeerError()
+      }
+
+      // 2. Create your encryption box/unbox wrapper
+      const wrapper = duplexPair<Uint8Array>()
+      const encrypt = transform() // Use transform iterables to modify data
+      const decrypt = transform()
+
+      void pipe(
+        wrapper[0], // We write to wrapper
+        encrypt, // The data is encrypted
+        shake.stream, // It goes to the remote peer
+        decrypt, // Decrypt the incoming data
+        wrapper[0] // Pipe to the wrapper
+      )
+
+      return {
+        conn: {
+          ...wrapper[1],
+          close: async () => {},
+          localAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4001'),
+          remoteAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4002'),
+          timeline: {
+            open: Date.now()
+          },
+          conn: true
+        },
+        remotePeer,
+        remoteEarlyData: new Uint8Array(0)
+      }
+    },
+    secureOutbound: async (localPeer, duplex, remotePeer) => {
+      // 1. Perform a basic handshake.
+      const shake = handshake(duplex)
+      shake.write(localPeer.toBytes())
+      const remoteId = await shake.read()
+
+      if (remoteId == null) {
+        throw new Error('Could not read remote ID')
+      }
+
+      shake.rest()
+
+      // 2. Create your encryption box/unbox wrapper
+      const wrapper = duplexPair<Uint8Array>()
+      const encrypt = transform()
+      const decrypt = transform()
+
+      void pipe(
+        wrapper[0], // We write to wrapper
+        encrypt, // The data is encrypted
+        shake.stream, // It goes to the remote peer
+        decrypt, // Decrypt the incoming data
+        wrapper[0] // Pipe to the wrapper
+      )
+
+      return {
+        conn: {
+          ...wrapper[1],
+          close: async () => {},
+          localAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4001'),
+          remoteAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4002'),
+          timeline: {
+            open: Date.now()
+          },
+          conn: true
+        },
+        remotePeer: peerIdFromBytes(remoteId.slice()),
+        remoteEarlyData: new Uint8Array(0)
+      }
+    }
+  }
+
+  return encrypter
+}

package/src/mocks/connection-manager.ts

@@ -1,9 +1,21 @@
 import { EventEmitter } from '@libp2p/interfaces'
-import type { Connection } from '@libp2p/interfaces/src/connection'
-import type { PeerId } from '@libp2p/interfaces/src/peer-id'
-import type { ConnectionManager, ConnectionManagerEvents } from '@libp2p/interfaces/src/registrar'
+import type { Connection } from '@libp2p/interfaces/connection'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { ConnectionManager, ConnectionManagerEvents } from '@libp2p/interfaces/registrar'
 
 class MockConnectionManager extends EventEmitter<ConnectionManagerEvents> implements ConnectionManager {
+  getConnectionMap (): Map<string, Connection[]> {
+    throw new Error('Method not implemented.')
+  }
+
+  getConnectionList (): Connection[] {
+    throw new Error('Method not implemented.')
+  }
+
+  getConnections (): Connection[] {
+    throw new Error('Method not implemented.')
+  }
+
   getConnection (peerId: PeerId): Connection | undefined {
     throw new Error('Method not implemented.')
   }

package/src/mocks/connection.ts

@@ -2,16 +2,19 @@ import { peerIdFromString } from '@libp2p/peer-id'
 import { pipe } from 'it-pipe'
 import { duplexPair } from 'it-pair/duplex'
 import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
-import type { Connection, Stream, Metadata, ProtocolStream } from '@libp2p/interfaces/connection'
+import type { Connection, Stream, Metadata, ProtocolStream, ConnectionStat } from '@libp2p/interfaces/connection'
 import type { Duplex } from 'it-stream-types'
 import { mockMuxer } from './muxer.js'
-import type { PeerId } from '@libp2p/interfaces/src/peer-id'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
 import { mockMultiaddrConnection } from './multiaddr-connection.js'
 import type { Registrar } from '@libp2p/interfaces/registrar'
 import { mockRegistrar } from './registrar.js'
 import { Dialer, Listener } from '@libp2p/multistream-select'
 import { logger } from '@libp2p/logger'
-import { CustomEvent } from '@libp2p/interfaces'
+import * as STATUS from '@libp2p/interfaces/connection/status'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { StreamMuxer } from '@libp2p/interfaces/stream-muxer'
+import { Components } from '@libp2p/interfaces/components'
 
 const log = logger('libp2p:mock-connection')
 
@@ -20,6 +23,96 @@ export interface MockConnectionOptions {
   registrar?: Registrar
 }
 
+interface MockConnectionInit {
+  remoteAddr: Multiaddr
+  remotePeer: PeerId
+  direction: 'inbound' | 'outbound'
+  maConn: MultiaddrConnection
+  muxer: StreamMuxer
+}
+
+class MockConnection implements Connection {
+  public id: string
+  public remoteAddr: Multiaddr
+  public remotePeer: PeerId
+  public direction: 'inbound' | 'outbound'
+  public stat: ConnectionStat
+  public registry: Map<string, Metadata>
+  public streams: Stream[]
+  public tags: string[]
+
+  private readonly muxer: StreamMuxer
+  private readonly maConn: MultiaddrConnection
+
+  constructor (init: MockConnectionInit) {
+    const { remoteAddr, remotePeer, direction, maConn, muxer } = init
+
+    this.id = `mock-connection-${Math.random()}`
+    this.remoteAddr = remoteAddr
+    this.remotePeer = remotePeer
+    this.direction = direction
+    this.stat = {
+      status: STATUS.OPEN,
+      direction,
+      timeline: maConn.timeline,
+      multiplexer: 'test-multiplexer',
+      encryption: 'yes-yes-very-secure'
+    }
+    this.registry = new Map()
+    this.streams = []
+    this.tags = []
+    this.muxer = muxer
+    this.maConn = maConn
+  }
+
+  async newStream (protocols: string | string[]) {
+    if (!Array.isArray(protocols)) {
+      protocols = [protocols]
+    }
+
+    if (protocols.length === 0) {
+      throw new Error('protocols must have a length')
+    }
+
+    const id = `${Math.random()}`
+    const stream: Stream = this.muxer.newStream(id)
+    const mss = new Dialer(stream)
+    const result = await mss.select(protocols)
+
+    const streamData: ProtocolStream = {
+      protocol: result.protocol,
+      stream: {
+        ...stream,
+        ...result.stream
+      }
+    }
+
+    this.addStream(stream, { protocol: result.protocol, metadata: {} })
+
+    return streamData
+  }
+
+  addStream (stream: Stream, metadata: Partial<Metadata>) {
+    this.registry.set(stream.id, {
+      protocol: metadata.protocol ?? '',
+      metadata: metadata.metadata ?? {}
+    })
+
+    this.streams.push(stream)
+  }
+
+  removeStream (id: string) {
+    this.registry.delete(id)
+    this.streams = this.streams.filter(stream => stream.id !== id)
+  }
+
+  async close () {
+    this.stat.status = STATUS.CLOSING
+    await this.maConn.close()
+    this.stat.status = STATUS.CLOSED
+  }
+}
+
 export function mockConnection (maConn: MultiaddrConnection, opts: MockConnectionOptions = {}): Connection {
   const remoteAddr = maConn.remoteAddr
   const remotePeerIdStr = remoteAddr.getPeerId() ?? '12D3KooWCrhmFM1BCPGBkNzbPfDk4cjYmtAYSpZwUBC69Qg2kZyq'
@@ -29,12 +122,11 @@ export function mockConnection (maConn: MultiaddrConnection, opts: MockConnectio
   }
 
   const remotePeer = peerIdFromString(remotePeerIdStr)
-  const registry = new Map()
-  const streams: Stream[] = []
   const direction = opts.direction ?? 'inbound'
   const registrar = opts.registrar ?? mockRegistrar()
+  const muxerFactory = mockMuxer()
 
-  const muxer = mockMuxer({
+  const muxer = muxerFactory.createStreamMuxer(new Components(), {
     onIncomingStream: (muxedStream) => {
       const mss = new Listener(muxedStream)
       try {
@@ -46,9 +138,7 @@ export function mockConnection (maConn: MultiaddrConnection, opts: MockConnectio
             connection.addStream(muxedStream, { protocol, metadata: {} })
             const handler = registrar.getHandler(protocol)
 
-            handler(new CustomEvent('incomingStream', {
-              detail: { connection, stream: muxedStream, protocol }
-            }))
+            handler({ connection, stream: muxedStream, protocol })
           }).catch(err => {
             log.error(err)
           })
@@ -65,56 +155,13 @@ export function mockConnection (maConn: MultiaddrConnection, opts: MockConnectio
     maConn, muxer, maConn
   )
 
-  const connection: Connection = {
-    id: 'mock-connection',
+  const connection = new MockConnection({
     remoteAddr,
     remotePeer,
-    stat: {
-      status: 'OPEN',
-      direction,
-      timeline: maConn.timeline,
-      multiplexer: 'test-multiplexer',
-      encryption: 'yes-yes-very-secure'
-    },
-    registry,
-    tags: [],
-    streams,
-    newStream: async (protocols) => {
-      if (!Array.isArray(protocols)) {
-        protocols = [protocols]
-      }
-
-      if (protocols.length === 0) {
-        throw new Error('protocols must have a length')
-      }
-
-      const id = `${Math.random()}`
-      const stream: Stream = muxer.newStream(id)
-      const mss = new Dialer(stream)
-      const result = await mss.select(protocols)
-
-      const streamData: ProtocolStream = {
-        protocol: result.protocol,
-        stream: {
-          ...stream,
-          ...result.stream
-        }
-      }
-
-      registry.set(id, streamData)
-
-      return streamData
-    },
-    addStream: (stream: Stream, metadata: Metadata) => {
-
-    },
-    removeStream: (id: string) => {
-      registry.delete(id)
-    },
-    close: async () => {
-      await maConn.close()
-    }
-  }
+    direction,
+    maConn,
+    muxer
+  })
 
   return connection
 }

package/src/mocks/duplex.ts

@@ -0,0 +1,8 @@
+import type { Duplex } from 'it-stream-types'
+
+export function mockDuplex (): Duplex<Uint8Array> {
+  return {
+    source: [],
+    sink: async () => {}
+  }
+}

package/src/mocks/index.ts

@@ -2,8 +2,9 @@
 export { mockConnectionGater } from './connection-gater.js'
 export { mockConnectionManager } from './connection-manager.js'
 export { mockConnection, mockStream, connectionPair } from './connection.js'
-export { mockMultiaddrConnection } from './multiaddr-connection.js'
+export { mockMultiaddrConnection, mockMultiaddrConnPair } from './multiaddr-connection.js'
 export { mockMuxer } from './muxer.js'
 export { mockRegistrar } from './registrar.js'
 export { mockUpgrader } from './upgrader.js'
+export { mockDuplex } from './duplex.js'
 export type { MockUpgraderInit } from './upgrader.js'

package/src/mocks/multiaddr-connection.ts

@@ -1,4 +1,6 @@
 import { Multiaddr } from '@multiformats/multiaddr'
+import { duplexPair } from 'it-pair/duplex'
+import { abortableSource } from 'abortable-iterator'
 import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
 import type { Duplex } from 'it-stream-types'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
@@ -17,3 +19,48 @@ export function mockMultiaddrConnection (source: Duplex<Uint8Array> & Partial<Mu
 
   return maConn
 }
+
+export interface MockMultiaddrConnPairOptions {
+  addrs: Multiaddr[]
+  remotePeer: PeerId
+}
+
+/**
+ * Returns both sides of a mocked MultiaddrConnection
+ */
+export function mockMultiaddrConnPair (opts: MockMultiaddrConnPairOptions): { inbound: MultiaddrConnection, outbound: MultiaddrConnection } {
+  const { addrs, remotePeer } = opts
+  const controller = new AbortController()
+  const [localAddr, remoteAddr] = addrs
+  const [inboundStream, outboundStream] = duplexPair<Uint8Array>()
+
+  const outbound: MultiaddrConnection = {
+    ...outboundStream,
+    remoteAddr: remoteAddr.encapsulate(`/p2p/${remotePeer.toString()}`),
+    timeline: {
+      open: Date.now()
+    },
+    close: async () => {
+      outbound.timeline.close = Date.now()
+      controller.abort()
+    }
+  }
+
+  const inbound: MultiaddrConnection = {
+    ...inboundStream,
+    remoteAddr: localAddr,
+    timeline: {
+      open: Date.now()
+    },
+    close: async () => {
+      inbound.timeline.close = Date.now()
+      controller.abort()
+    }
+  }
+
+  // Make the sources abortable so we can close them easily
+  inbound.source = abortableSource(inbound.source, controller.signal)
+  outbound.source = abortableSource(outbound.source, controller.signal)
+
+  return { inbound, outbound }
+}

package/src/mocks/muxer.ts

@@ -7,10 +7,11 @@ import errCode from 'err-code'
 import { Logger, logger } from '@libp2p/logger'
 import * as ndjson from 'it-ndjson'
 import type { Stream } from '@libp2p/interfaces/connection'
-import type { Muxer, MuxerInit } from '@libp2p/interfaces/stream-muxer'
+import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interfaces/stream-muxer'
 import type { Source } from 'it-stream-types'
 import { pipe } from 'it-pipe'
 import map from 'it-map'
+import type { Components } from '@libp2p/interfaces/components'
 
 let muxers = 0
 let streams = 0
@@ -216,19 +217,20 @@ class MuxedStream {
   }
 }
 
-class MockMuxer implements Muxer {
+class MockMuxer implements StreamMuxer {
   public source: Source<Uint8Array>
   public input: Pushable<Uint8Array>
   public streamInput: Pushable<StreamMessage>
   public name: string
+  public protocol: string = '/mock-muxer/1.0.0'
 
   private readonly registryInitiatorStreams: Map<string, MuxedStream>
   private readonly registryRecipientStreams: Map<string, MuxedStream>
-  private readonly options: MuxerInit
+  private readonly options: StreamMuxerInit
 
   private readonly log: Logger
 
-  constructor (init?: MuxerInit) {
+  constructor (init?: StreamMuxerInit) {
     this.name = `muxer:${muxers++}`
     this.log = logger(`libp2p:mock-muxer:${this.name}`)
     this.registryInitiatorStreams = new Map()
@@ -349,21 +351,29 @@ class MockMuxer implements Muxer {
   }
 }
 
-export function mockMuxer (init?: MuxerInit): Muxer {
-  const mockMuxer = new MockMuxer(init)
-
-  void Promise.resolve().then(async () => {
-    void pipe(
-      mockMuxer.streamInput,
-      ndjson.stringify,
-      (source) => map(source, str => uint8ArrayFromString(str)),
-      async (source) => {
-        for await (const buf of source) {
-          mockMuxer.input.push(buf)
+class MockMuxerFactory implements StreamMuxerFactory {
+  public protocol: string = '/mock-muxer/1.0.0'
+
+  createStreamMuxer (c: Components, init?: StreamMuxerInit): StreamMuxer {
+    const mockMuxer = new MockMuxer(init)
+
+    void Promise.resolve().then(async () => {
+      void pipe(
+        mockMuxer.streamInput,
+        ndjson.stringify,
+        (source) => map(source, str => uint8ArrayFromString(str)),
+        async (source) => {
+          for await (const buf of source) {
+            mockMuxer.input.push(buf)
+          }
         }
-      }
-    )
-  })
+      )
+    })
+
+    return mockMuxer
+  }
+}
 
-  return mockMuxer
+export function mockMuxer (): MockMuxerFactory {
+  return new MockMuxerFactory()
 }

package/src/mocks/registrar.ts

@@ -1,13 +1,12 @@
 import type { IncomingStreamData, Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
-import type { Connection } from '@libp2p/interfaces/src/connection'
-import type { PeerId } from '@libp2p/interfaces/src/peer-id'
+import type { Connection } from '@libp2p/interfaces/connection'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
 import type { Topology } from '@libp2p/interfaces/topology'
 import { connectionPair } from './connection.js'
-import { CustomEvent } from '@libp2p/interfaces'
 
 export class MockRegistrar implements Registrar {
   private readonly topologies: Map<string, { topology: Topology, protocols: string[] }> = new Map()
-  private readonly handlers: Map<string, { handler: StreamHandler, protocols: string[] }> = new Map()
+  private readonly handlers: Map<string, StreamHandler> = new Map()
 
   getProtocols () {
     const protocols = new Set<string>()
@@ -16,51 +15,44 @@ export class MockRegistrar implements Registrar {
       topology.protocols.forEach(protocol => protocols.add(protocol))
     }
 
-    for (const handler of this.handlers.values()) {
-      handler.protocols.forEach(protocol => protocols.add(protocol))
+    for (const protocol of this.handlers.keys()) {
+      protocols.add(protocol)
     }
 
     return Array.from(protocols).sort()
   }
 
-  async handle (protocols: string | string[], handler: StreamHandler) {
-    if (!Array.isArray(protocols)) {
-      protocols = [protocols]
-    }
+  async handle (protocols: string | string[], handler: StreamHandler): Promise<void> {
+    const protocolList = Array.isArray(protocols) ? protocols : [protocols]
 
-    for (const protocol of protocols) {
-      for (const { protocols } of this.handlers.values()) {
-        if (protocols.includes(protocol)) {
-          throw new Error(`Handler already registered for protocol ${protocol}`)
-        }
+    for (const protocol of protocolList) {
+      if (this.handlers.has(protocol)) {
+        throw new Error(`Handler already registered for protocol ${protocol}`)
       }
+
+      this.handlers.set(protocol, handler)
     }
+  }
 
-    const id = `handler-id-${Math.random()}`
+  async unhandle (protocols: string | string[]) {
+    const protocolList = Array.isArray(protocols) ? protocols : [protocols]
 
-    this.handlers.set(id, {
-      handler,
-      protocols
+    protocolList.forEach(protocol => {
+      this.handlers.delete(protocol)
     })
-
-    return id
-  }
-
-  async unhandle (id: string) {
-    this.handlers.delete(id)
   }
 
   getHandler (protocol: string) {
-    for (const { handler, protocols } of this.handlers.values()) {
-      if (protocols.includes(protocol)) {
-        return handler
-      }
+    const handler = this.handlers.get(protocol)
+
+    if (handler == null) {
+      throw new Error(`No handler registered for protocol ${protocol}`)
     }
 
-    throw new Error(`No handler registered for protocol ${protocol}`)
+    return handler
   }
 
-  register (protocols: string | string[], topology: Topology) {
+  async register (protocols: string | string[], topology: Topology) {
     if (!Array.isArray(protocols)) {
       protocols = [protocols]
     }
@@ -104,16 +96,14 @@ export function mockRegistrar () {
   return new MockRegistrar()
 }
 
-export async function mockIncomingStreamEvent (protocol: string, conn: Connection, remotePeer: PeerId): Promise<CustomEvent<IncomingStreamData>> {
-  // @ts-expect-error incomplete implementation
-  return new CustomEvent('incomingStream', {
-    detail: {
-      ...await conn.newStream([protocol]),
-      connection: {
-        remotePeer
-      }
+export async function mockIncomingStreamEvent (protocol: string, conn: Connection, remotePeer: PeerId): Promise<IncomingStreamData> {
+  return {
+    ...await conn.newStream([protocol]),
+    // @ts-expect-error incomplete implementation
+    connection: {
+      remotePeer
     }
-  })
+  }
 }
 
 export interface Peer {

package/src/mocks/upgrader.ts

@@ -1,36 +1,46 @@
 import { expect } from 'aegir/utils/chai.js'
 import { mockConnection } from './connection.js'
-import type { Upgrader, MultiaddrConnection } from '@libp2p/interfaces/transport'
+import type { Upgrader, MultiaddrConnection, UpgraderEvents } from '@libp2p/interfaces/transport'
 import type { Registrar } from '@libp2p/interfaces/registrar'
+import { EventEmitter } from '@libp2p/interfaces'
 
 export interface MockUpgraderInit {
   registrar?: Registrar
 }
 
-export function mockUpgrader (init: MockUpgraderInit = {}) {
-  const ensureProps = (multiaddrConnection: MultiaddrConnection) => {
-    ['sink', 'source', 'remoteAddr', 'timeline', 'close'].forEach(prop => {
-      expect(multiaddrConnection).to.have.property(prop)
+function ensureProps (multiaddrConnection: MultiaddrConnection) {
+  ['sink', 'source', 'remoteAddr', 'timeline', 'close'].forEach(prop => {
+    expect(multiaddrConnection).to.have.property(prop)
+  })
+  return multiaddrConnection
+}
+
+class MockUpgrader extends EventEmitter<UpgraderEvents> implements Upgrader {
+  private readonly registrar?: Registrar
+
+  constructor (init: MockUpgraderInit = {}) {
+    super()
+
+    this.registrar = init.registrar
+  }
+
+  async upgradeOutbound (multiaddrConnection: MultiaddrConnection) {
+    ensureProps(multiaddrConnection)
+    return mockConnection(multiaddrConnection, {
+      direction: 'outbound',
+      registrar: this.registrar
     })
-    return multiaddrConnection
   }
 
-  const upgrader: Upgrader = {
-    async upgradeOutbound (multiaddrConnection) {
-      ensureProps(multiaddrConnection)
-      return mockConnection(multiaddrConnection, {
-        direction: 'outbound',
-        registrar: init.registrar
-      })
-    },
-    async upgradeInbound (multiaddrConnection) {
-      ensureProps(multiaddrConnection)
-      return mockConnection(multiaddrConnection, {
-        direction: 'inbound',
-        registrar: init.registrar
-      })
-    }
+  async upgradeInbound (multiaddrConnection: MultiaddrConnection) {
+    ensureProps(multiaddrConnection)
+    return mockConnection(multiaddrConnection, {
+      direction: 'inbound',
+      registrar: this.registrar
+    })
   }
+}
 
-  return upgrader
+export function mockUpgrader (init: MockUpgraderInit = {}) {
+  return new MockUpgrader(init)
 }