@libp2p/interface-compliance-tests 3.0.7-ea8a0637 → 3.0.7-eabf6f36

package/src/connection-encryption/index.ts

@@ -0,0 +1,97 @@
+import { UnexpectedPeerError } from '@libp2p/interface/errors'
+import * as PeerIdFactory from '@libp2p/peer-id-factory'
+import { expect } from 'aegir/chai'
+import all from 'it-all'
+import { pipe } from 'it-pipe'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import peers from '../peers.js'
+import { createMaConnPair } from './utils/index.js'
+import type { TestSetup } from '../index.js'
+import type { ConnectionEncrypter } from '@libp2p/interface/connection-encrypter'
+import type { PeerId } from '@libp2p/interface/peer-id'
+
+export default (common: TestSetup<ConnectionEncrypter>): void => {
+  describe('interface-connection-encrypter compliance tests', () => {
+    let crypto: ConnectionEncrypter
+    let localPeer: PeerId
+    let remotePeer: PeerId
+    let mitmPeer: PeerId
+
+    before(async () => {
+      [
+        crypto,
+        localPeer,
+        remotePeer,
+        mitmPeer
+      ] = await Promise.all([
+        common.setup(),
+        PeerIdFactory.createFromJSON(peers[0]),
+        PeerIdFactory.createFromJSON(peers[1]),
+        PeerIdFactory.createFromJSON(peers[2])
+      ])
+    })
+
+    after(async () => {
+      await common.teardown()
+    })
+
+    it('has a protocol string', () => {
+      expect(crypto.protocol).to.exist()
+      expect(crypto.protocol).to.be.a('string')
+    })
+
+    it('it wraps the provided duplex connection', async () => {
+      const [localConn, remoteConn] = createMaConnPair()
+
+      const [
+        inboundResult,
+        outboundResult
+      ] = await Promise.all([
+        crypto.secureInbound(remotePeer, localConn),
+        crypto.secureOutbound(localPeer, remoteConn, remotePeer)
+      ])
+
+      // Echo server
+      void pipe(inboundResult.conn, inboundResult.conn)
+
+      // Send some data and collect the result
+      const input = uint8ArrayFromString('data to encrypt')
+      const result = await pipe(
+        [input],
+        outboundResult.conn,
+        async (source) => all(source)
+      )
+
+      expect(result).to.eql([input])
+    })
+
+    it('should return the remote peer id', async () => {
+      const [localConn, remoteConn] = createMaConnPair()
+
+      const [
+        inboundResult,
+        outboundResult
+      ] = await Promise.all([
+        crypto.secureInbound(remotePeer, localConn),
+        crypto.secureOutbound(localPeer, remoteConn, remotePeer)
+      ])
+
+      // Inbound should return the initiator (local) peer
+      expect(inboundResult.remotePeer.toBytes()).to.equalBytes(localPeer.toBytes())
+      // Outbound should return the receiver (remote) peer
+      expect(outboundResult.remotePeer.toBytes()).to.equalBytes(remotePeer.toBytes())
+    })
+
+    it('inbound connections should verify peer integrity if known', async () => {
+      const [localConn, remoteConn] = createMaConnPair()
+
+      await Promise.all([
+        crypto.secureInbound(remotePeer, localConn, mitmPeer),
+        crypto.secureOutbound(localPeer, remoteConn, remotePeer)
+      ]).then(() => expect.fail(), (err) => {
+        expect(err).to.exist()
+        expect(err).to.have.property('code', UnexpectedPeerError.code)
+      })
+    })
+  })
+}

package/src/connection-encryption/utils/index.ts

@@ -0,0 +1,24 @@
+import { multiaddr } from '@multiformats/multiaddr'
+import { duplexPair } from 'it-pair/duplex'
+import type { MultiaddrConnection } from '@libp2p/interface/connection'
+import type { Duplex, Source } from 'it-stream-types'
+
+export function createMaConnPair (): [MultiaddrConnection, MultiaddrConnection] {
+  const [local, remote] = duplexPair<Uint8Array>()
+
+  function duplexToMaConn (duplex: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>): MultiaddrConnection {
+    const output: MultiaddrConnection = {
+      ...duplex,
+      close: async () => {},
+      abort: () => {},
+      remoteAddr: multiaddr('/ip4/127.0.0.1/tcp/4001'),
+      timeline: {
+        open: Date.now()
+      }
+    }
+
+    return output
+  }
+
+  return [duplexToMaConn(local), duplexToMaConn(remote)]
+}

package/src/index.ts

@@ -1,4 +1,3 @@
-
 export interface TestSetup<T, SetupArgs = Record<string, unknown>> {
   setup: (args?: SetupArgs) => Promise<T>
   teardown: () => Promise<void>

package/src/is-valid-tick.ts

@@ -1,4 +1,3 @@
-
 /**
  * A tick is considered valid if it happened between now
  * and `ms` milliseconds ago

package/src/mocks/connection-encrypter.ts

@@ -0,0 +1,113 @@
+import { UnexpectedPeerError } from '@libp2p/interface/errors'
+import { peerIdFromBytes } from '@libp2p/peer-id'
+import { multiaddr } from '@multiformats/multiaddr'
+import { handshake } from 'it-handshake'
+import map from 'it-map'
+import { duplexPair } from 'it-pair/duplex'
+import { pipe } from 'it-pipe'
+import type { ConnectionEncrypter } from '@libp2p/interface/connection-encrypter'
+import type { Transform, Source } from 'it-stream-types'
+
+// A basic transform that does nothing to the data
+const transform = <T>(): Transform<Source<T>, AsyncGenerator<T>> => {
+  return (source: Source<T>) => (async function * () {
+    for await (const chunk of source) {
+      yield chunk
+    }
+  })()
+}
+
+export function mockConnectionEncrypter (): ConnectionEncrypter {
+  const encrypter: ConnectionEncrypter = {
+    protocol: 'insecure',
+    secureInbound: async (localPeer, duplex, expectedPeer) => {
+      // 1. Perform a basic handshake.
+      const shake = handshake<Uint8Array>(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?.equals(remotePeer) === false) {
+        throw new UnexpectedPeerError()
+      }
+
+      // 2. Create your encryption box/unbox wrapper
+      const wrapper = duplexPair<Uint8Array>()
+      const encrypt = transform<Uint8Array>() // Use transform iterables to modify data
+      const decrypt = transform<Uint8Array>()
+
+      void pipe(
+        wrapper[0], // We write to wrapper
+        encrypt, // The data is encrypted
+        shake.stream, // It goes to the remote peer
+        source => map(source, (list) => list.subarray()), // turn lists into arrays
+        decrypt, // Decrypt the incoming data
+        wrapper[0] // Pipe to the wrapper
+      )
+
+      return {
+        conn: {
+          ...wrapper[1],
+          close: async () => { },
+          localAddr: multiaddr('/ip4/127.0.0.1/tcp/4001'),
+          remoteAddr: multiaddr('/ip4/127.0.0.1/tcp/4002'),
+          timeline: {
+            open: Date.now()
+          },
+          conn: true
+        },
+        remotePeer,
+        remoteExtensions: {}
+      }
+    },
+    secureOutbound: async (localPeer, duplex, remotePeer) => {
+      // 1. Perform a basic handshake.
+      const shake = handshake<Uint8Array>(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<Uint8Array>()
+      const decrypt = transform<Uint8Array>()
+
+      void pipe(
+        wrapper[0], // We write to wrapper
+        encrypt, // The data is encrypted
+        shake.stream, // It goes to the remote peer
+        source => map(source, (list) => list.subarray()), // turn lists into arrays
+        decrypt, // Decrypt the incoming data
+        wrapper[0] // Pipe to the wrapper
+      )
+
+      return {
+        conn: {
+          ...wrapper[1],
+          close: async () => { },
+          localAddr: multiaddr('/ip4/127.0.0.1/tcp/4001'),
+          remoteAddr: multiaddr('/ip4/127.0.0.1/tcp/4002'),
+          timeline: {
+            open: Date.now()
+          },
+          conn: true
+        },
+        remotePeer: peerIdFromBytes(remoteId.slice()),
+        remoteExtensions: {}
+      }
+    }
+  }
+
+  return encrypter
+}

package/src/mocks/connection-gater.ts

@@ -0,0 +1,18 @@
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
+
+export function mockConnectionGater (): ConnectionGater {
+  return {
+    denyDialPeer: async () => Promise.resolve(false),
+    denyDialMultiaddr: async () => Promise.resolve(false),
+    denyInboundConnection: async () => Promise.resolve(false),
+    denyOutboundConnection: async () => Promise.resolve(false),
+    denyInboundEncryptedConnection: async () => Promise.resolve(false),
+    denyOutboundEncryptedConnection: async () => Promise.resolve(false),
+    denyInboundUpgradedConnection: async () => Promise.resolve(false),
+    denyOutboundUpgradedConnection: async () => Promise.resolve(false),
+    denyInboundRelayReservation: async () => Promise.resolve(false),
+    denyOutboundRelayedConnection: async () => Promise.resolve(false),
+    denyInboundRelayedConnection: async () => Promise.resolve(false),
+    filterMultiaddrForPeer: async () => Promise.resolve(true)
+  }
+}

package/src/mocks/connection-manager.ts

@@ -0,0 +1,211 @@
+import { CodeError } from '@libp2p/interface/errors'
+import { isPeerId, type PeerId } from '@libp2p/interface/peer-id'
+import { PeerMap } from '@libp2p/peer-collections'
+import { peerIdFromString } from '@libp2p/peer-id'
+import { isMultiaddr, type Multiaddr } from '@multiformats/multiaddr'
+import { connectionPair } from './connection.js'
+import type { Libp2pEvents, PendingDial } from '@libp2p/interface'
+import type { Connection } from '@libp2p/interface/connection'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { PubSub } from '@libp2p/interface/pubsub'
+import type { Startable } from '@libp2p/interface/startable'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
+
+export interface MockNetworkComponents {
+  peerId: PeerId
+  registrar: Registrar
+  connectionManager: ConnectionManager
+  events: EventEmitter<Libp2pEvents>
+  pubsub?: PubSub
+}
+
+class MockNetwork {
+  private components: MockNetworkComponents[] = []
+
+  addNode (components: MockNetworkComponents): void {
+    this.components.push(components)
+  }
+
+  getNode (peerId: PeerId | Multiaddr []): MockNetworkComponents {
+    if (Array.isArray(peerId) && peerId.length > 0) {
+      peerId = peerIdFromString(peerId[0].getPeerId() ?? '')
+    } else if (isPeerId(peerId)) {
+      for (const components of this.components) {
+        if (peerId.equals(components.peerId)) {
+          return components
+        }
+      }
+    }
+
+    throw new CodeError('Peer not found', 'ERR_PEER_NOT_FOUND')
+  }
+
+  reset (): void {
+    this.components = []
+  }
+}
+
+export const mockNetwork = new MockNetwork()
+
+export interface MockConnectionManagerComponents {
+  peerId: PeerId
+  registrar: Registrar
+  events: EventEmitter<Libp2pEvents>
+}
+
+class MockConnectionManager implements ConnectionManager, Startable {
+  private connections: Connection[] = []
+  private readonly components: MockConnectionManagerComponents
+  private started = false
+
+  constructor (components: MockConnectionManagerComponents) {
+    this.components = components
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  async start (): Promise<void> {
+    this.started = true
+  }
+
+  async stop (): Promise<void> {
+    for (const connection of this.connections) {
+      await this.closeConnections(connection.remotePeer)
+    }
+
+    this.started = false
+  }
+
+  getConnections (peerId?: PeerId): Connection[] {
+    if (peerId != null) {
+      return this.connections
+        .filter(c => c.remotePeer.toString() === peerId.toString())
+    }
+
+    return this.connections
+  }
+
+  getConnectionsMap (): PeerMap<Connection[]> {
+    const map = new PeerMap<Connection[]>()
+
+    for (const conn of this.connections) {
+      const conns: Connection[] = map.get(conn.remotePeer) ?? []
+      conns.push(conn)
+
+      map.set(conn.remotePeer, conns)
+    }
+
+    return map
+  }
+
+  async openConnection (peerId: PeerId | Multiaddr | Multiaddr[]): Promise<Connection> {
+    if (this.components == null) {
+      throw new CodeError('Not initialized', 'ERR_NOT_INITIALIZED')
+    }
+
+    if (isMultiaddr(peerId)) {
+      throw new CodeError('Dialing multiaddrs not supported', 'ERR_NOT_SUPPORTED')
+    }
+
+    let existingConnections: Connection[] = []
+
+    if (Array.isArray(peerId) && peerId.length > 0) {
+      existingConnections = this.getConnections(peerIdFromString(peerId[0].getPeerId() ?? ''))
+    } else if (isPeerId(peerId)) {
+      existingConnections = this.getConnections(peerId)
+    }
+
+    if (existingConnections.length > 0) {
+      return existingConnections[0]
+    }
+
+    const componentsB = mockNetwork.getNode(peerId)
+
+    const [aToB, bToA] = connectionPair(this.components, componentsB)
+
+    // track connections
+    this.connections.push(aToB)
+    ;(componentsB.connectionManager as MockConnectionManager).connections.push(bToA)
+
+    this.components.events.safeDispatchEvent('connection:open', {
+      detail: aToB
+    })
+
+    for (const protocol of this.components.registrar.getProtocols()) {
+      for (const topology of this.components.registrar.getTopologies(protocol)) {
+        topology.onConnect?.(componentsB.peerId, aToB)
+      }
+    }
+
+    this.components.events.safeDispatchEvent('peer:connect', { detail: componentsB.peerId })
+
+    componentsB.events.safeDispatchEvent('connection:open', {
+      detail: bToA
+    })
+
+    for (const protocol of componentsB.registrar.getProtocols()) {
+      for (const topology of componentsB.registrar.getTopologies(protocol)) {
+        topology.onConnect?.(this.components.peerId, bToA)
+      }
+    }
+
+    componentsB.events.safeDispatchEvent('peer:connect', { detail: this.components.peerId })
+
+    return aToB
+  }
+
+  async closeConnections (peerId: PeerId): Promise<void> {
+    if (this.components == null) {
+      throw new CodeError('Not initialized', 'ERR_NOT_INITIALIZED')
+    }
+
+    const connections = this.getConnections(peerId)
+
+    if (connections.length === 0) {
+      return
+    }
+
+    const componentsB = mockNetwork.getNode(peerId)
+
+    for (const protocol of this.components.registrar.getProtocols()) {
+      this.components.registrar.getTopologies(protocol).forEach(topology => {
+        topology.onDisconnect?.(componentsB.peerId)
+      })
+    }
+
+    for (const conn of connections) {
+      await conn.close()
+    }
+
+    this.connections = this.connections.filter(c => !c.remotePeer.equals(peerId))
+
+    if (this.connections.filter(c => !c.remotePeer.equals(peerId)).length === 0) {
+      componentsB.events.safeDispatchEvent('peer:disconnect', { detail: peerId })
+    }
+
+    await componentsB.connectionManager?.closeConnections(this.components.peerId)
+
+    if (componentsB.connectionManager?.getConnectionsMap().get(this.components.peerId) == null) {
+      componentsB.events.safeDispatchEvent('peer:disconnect', { detail: this.components.peerId })
+    }
+  }
+
+  async acceptIncomingConnection (): Promise<boolean> {
+    return true
+  }
+
+  afterUpgradeInbound (): void {
+
+  }
+
+  getDialQueue (): PendingDial[] {
+    return []
+  }
+}
+
+export function mockConnectionManager (components: MockConnectionManagerComponents): ConnectionManager {
+  return new MockConnectionManager(components)
+}

package/src/mocks/connection.ts

@@ -0,0 +1,226 @@
+import { CodeError } from '@libp2p/interface/errors'
+import { logger } from '@libp2p/logger'
+import * as mss from '@libp2p/multistream-select'
+import { peerIdFromString } from '@libp2p/peer-id'
+import { duplexPair } from 'it-pair/duplex'
+import { pipe } from 'it-pipe'
+import { mockMultiaddrConnection } from './multiaddr-connection.js'
+import { mockMuxer } from './muxer.js'
+import { mockRegistrar } from './registrar.js'
+import type { AbortOptions } from '@libp2p/interface'
+import type { MultiaddrConnection, Connection, Stream, Direction, ConnectionTimeline, ConnectionStatus } from '@libp2p/interface/connection'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface/stream-muxer'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Duplex, Source } from 'it-stream-types'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+const log = logger('libp2p:mock-connection')
+
+export interface MockConnectionOptions {
+  direction?: Direction
+  registrar?: Registrar
+  muxerFactory?: StreamMuxerFactory
+}
+
+interface MockConnectionInit {
+  remoteAddr: Multiaddr
+  remotePeer: PeerId
+  direction: Direction
+  maConn: MultiaddrConnection
+  muxer: StreamMuxer
+}
+
+class MockConnection implements Connection {
+  public id: string
+  public remoteAddr: Multiaddr
+  public remotePeer: PeerId
+  public direction: Direction
+  public timeline: ConnectionTimeline
+  public multiplexer?: string
+  public encryption?: string
+  public status: ConnectionStatus
+  public streams: Stream[]
+  public tags: string[]
+  public transient: boolean
+
+  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.status = 'open'
+    this.direction = direction
+    this.timeline = maConn.timeline
+    this.multiplexer = 'test-multiplexer'
+    this.encryption = 'yes-yes-very-secure'
+    this.streams = []
+    this.tags = []
+    this.muxer = muxer
+    this.maConn = maConn
+    this.transient = false
+  }
+
+  async newStream (protocols: string | string[], options?: AbortOptions): Promise<Stream> {
+    if (!Array.isArray(protocols)) {
+      protocols = [protocols]
+    }
+
+    if (protocols.length === 0) {
+      throw new Error('protocols must have a length')
+    }
+
+    if (this.status !== 'open') {
+      throw new CodeError('connection must be open to create streams', 'ERR_CONNECTION_CLOSED')
+    }
+
+    const id = `${Math.random()}`
+    const stream = await this.muxer.newStream(id)
+    const result = await mss.select(stream, protocols, options)
+
+    stream.protocol = result.protocol
+    stream.direction = 'outbound'
+    stream.sink = result.stream.sink
+    stream.source = result.stream.source
+
+    this.streams.push(stream)
+
+    return stream
+  }
+
+  addStream (stream: Stream): void {
+    this.streams.push(stream)
+  }
+
+  removeStream (id: string): void {
+    this.streams = this.streams.filter(stream => stream.id !== id)
+  }
+
+  async close (options?: AbortOptions): Promise<void> {
+    this.status = 'closing'
+    await Promise.all(
+      this.streams.map(async s => s.close(options))
+    )
+    await this.maConn.close()
+    this.status = 'closed'
+    this.timeline.close = Date.now()
+  }
+
+  abort (err: Error): void {
+    this.status = 'closing'
+    this.streams.forEach(s => {
+      s.abort(err)
+    })
+    this.maConn.abort(err)
+    this.status = 'closed'
+    this.timeline.close = Date.now()
+  }
+}
+
+export function mockConnection (maConn: MultiaddrConnection, opts: MockConnectionOptions = {}): Connection {
+  const remoteAddr = maConn.remoteAddr
+  const remotePeerIdStr = remoteAddr.getPeerId() ?? '12D3KooWCrhmFM1BCPGBkNzbPfDk4cjYmtAYSpZwUBC69Qg2kZyq'
+
+  if (remotePeerIdStr == null) {
+    throw new Error('Remote multiaddr must contain a peer id')
+  }
+
+  const remotePeer = peerIdFromString(remotePeerIdStr)
+  const direction = opts.direction ?? 'inbound'
+  const registrar = opts.registrar ?? mockRegistrar()
+  const muxerFactory = opts.muxerFactory ?? mockMuxer()
+
+  const muxer = muxerFactory.createStreamMuxer({
+    direction,
+    onIncomingStream: (muxedStream) => {
+      try {
+        mss.handle(muxedStream, registrar.getProtocols())
+          .then(({ stream, protocol }) => {
+            log('%s: incoming stream opened on %s', direction, protocol)
+            muxedStream.protocol = protocol
+            muxedStream.sink = stream.sink
+            muxedStream.source = stream.source
+
+            connection.addStream(muxedStream)
+            const { handler } = registrar.getHandler(protocol)
+
+            handler({ connection, stream: muxedStream })
+          }).catch(err => {
+            log.error(err)
+          })
+      } catch (err: any) {
+        log.error(err)
+      }
+    },
+    onStreamEnd: (muxedStream) => {
+      connection.removeStream(muxedStream.id)
+    }
+  })
+
+  void pipe(
+    maConn, muxer, maConn
+  )
+
+  const connection = new MockConnection({
+    remoteAddr,
+    remotePeer,
+    direction,
+    maConn,
+    muxer
+  })
+
+  return connection
+}
+
+export function mockStream (stream: Duplex<AsyncGenerator<Uint8ArrayList>, Source<Uint8ArrayList | Uint8Array>, Promise<void>>): Stream {
+  return {
+    ...stream,
+    close: async () => {},
+    closeRead: async () => {},
+    closeWrite: async () => {},
+    abort: () => {},
+    direction: 'outbound',
+    protocol: '/foo/1.0.0',
+    timeline: {
+      open: Date.now()
+    },
+    metadata: {},
+    id: `stream-${Date.now()}`,
+    status: 'open',
+    readStatus: 'ready',
+    writeStatus: 'ready'
+  }
+}
+
+export interface Peer {
+  peerId: PeerId
+  registrar: Registrar
+}
+
+export function multiaddrConnectionPair (a: { peerId: PeerId, registrar: Registrar }, b: { peerId: PeerId, registrar: Registrar }): [ MultiaddrConnection, MultiaddrConnection ] {
+  const [peerBtoPeerA, peerAtoPeerB] = duplexPair<Uint8Array>()
+
+  return [
+    mockMultiaddrConnection(peerAtoPeerB, b.peerId),
+    mockMultiaddrConnection(peerBtoPeerA, a.peerId)
+  ]
+}
+
+export function connectionPair (a: { peerId: PeerId, registrar: Registrar }, b: { peerId: PeerId, registrar: Registrar }): [ Connection, Connection ] {
+  const [peerBtoPeerA, peerAtoPeerB] = multiaddrConnectionPair(a, b)
+
+  return [
+    mockConnection(peerBtoPeerA, {
+      registrar: a.registrar
+    }),
+    mockConnection(peerAtoPeerB, {
+      registrar: b.registrar
+    })
+  ]
+}