@libp2p/interface-compliance-tests 6.4.16-cf9aab5c8 → 6.5.0-a02cb0461

package/dist/src/pubsub/utils.js

@@ -1,27 +0,0 @@
-import { generateKeyPair } from '@libp2p/crypto/keys';
-import { defaultLogger } from '@libp2p/logger';
-import { peerIdFromPrivateKey } from '@libp2p/peer-id';
-import { TypedEventEmitter } from 'main-event';
-import { pEvent } from 'p-event';
-import pWaitFor from 'p-wait-for';
-import { mockConnectionManager, mockRegistrar, mockNetwork } from '../mocks/index.js';
-export async function waitForSubscriptionUpdate(a, b) {
-    await pWaitFor(async () => {
-        const event = await pEvent(a, 'subscription-change');
-        return event.detail.peerId.equals(b);
-    });
-}
-export async function createComponents() {
-    const privateKey = await generateKeyPair('Ed25519');
-    const components = {
-        peerId: peerIdFromPrivateKey(privateKey),
-        privateKey,
-        registrar: mockRegistrar(),
-        events: new TypedEventEmitter(),
-        logger: defaultLogger()
-    };
-    components.connectionManager = mockConnectionManager(components);
-    mockNetwork.addNode(components);
-    return components;
-}
-//# sourceMappingURL=utils.js.map

package/dist/src/pubsub/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/pubsub/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAChC,OAAO,QAAQ,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAIrF,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAAE,CAAS,EAAE,CAAS;IACnE,MAAM,QAAQ,CAAC,KAAK,IAAI,EAAE;QACxB,MAAM,KAAK,GAAG,MAAM,MAAM,CAA6D,CAAC,EAAE,qBAAqB,CAAC,CAAA;QAEhH,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACtC,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,MAAM,UAAU,GAAG,MAAM,eAAe,CAAC,SAAS,CAAC,CAAA;IAEnD,MAAM,UAAU,GAAQ;QACtB,MAAM,EAAE,oBAAoB,CAAC,UAAU,CAAC;QACxC,UAAU;QACV,SAAS,EAAE,aAAa,EAAE;QAC1B,MAAM,EAAE,IAAI,iBAAiB,EAAE;QAC/B,MAAM,EAAE,aAAa,EAAE;KACxB,CAAA;IACD,UAAU,CAAC,iBAAiB,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAA;IAEhE,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;IAE/B,OAAO,UAAU,CAAA;AACnB,CAAC"}

package/dist/src/stream-muxer/mega-stress-test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mega-stress-test.d.ts","sourceRoot":"","sources":["../../../src/stream-muxer/mega-stress-test.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,EAAe,kBAAkB,EAAmB,MAAM,mBAAmB,CAAA;yBAEzE,QAAQ,SAAS,CAAC,kBAAkB,CAAC,KAAG,IAAI;AAA5D,wBASC"}

package/dist/src/stream-muxer/mega-stress-test.js

@@ -1,11 +0,0 @@
-import spawn from './spawner.js';
-export default (common) => {
-    const createMuxer = async (init) => {
-        const factory = await common.setup();
-        return factory.createStreamMuxer(init);
-    };
-    describe.skip('mega stress test', function () {
-        it('10,000 streams with 10,000 msg', async () => { await spawn(createMuxer, 10000, 10000, 5000); });
-    });
-};
-//# sourceMappingURL=mega-stress-test.js.map

package/dist/src/stream-muxer/mega-stress-test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mega-stress-test.js","sourceRoot":"","sources":["../../../src/stream-muxer/mega-stress-test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,cAAc,CAAA;AAIhC,eAAe,CAAC,MAAqC,EAAQ,EAAE;IAC7D,MAAM,WAAW,GAAG,KAAK,EAAE,IAAsB,EAAwB,EAAE;QACzE,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,KAAK,EAAE,CAAA;QACpC,OAAO,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAA;IACxC,CAAC,CAAA;IAED,QAAQ,CAAC,IAAI,CAAC,kBAAkB,EAAE;QAChC,EAAE,CAAC,gCAAgC,EAAE,KAAK,IAAI,EAAE,GAAG,MAAM,KAAK,CAAC,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAA,CAAC,CAAC,CAAC,CAAA;IACpG,CAAC,CAAC,CAAA;AACJ,CAAC,CAAA"}

package/dist/src/stream-muxer/spawner.d.ts

@@ -1,4 +0,0 @@
-import type { StreamMuxer, StreamMuxerInit } from '@libp2p/interface';
-declare const _default: (createMuxer: (init?: StreamMuxerInit) => Promise<StreamMuxer>, nStreams: number, nMsg: number, limit?: number) => Promise<void>;
-export default _default;
-//# sourceMappingURL=spawner.d.ts.map

package/dist/src/stream-muxer/spawner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"spawner.d.ts","sourceRoot":"","sources":["../../../src/stream-muxer/spawner.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;yBAE/C,aAAa,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,WAAW,CAAC,EAAE,UAAU,MAAM,EAAE,MAAM,MAAM,EAAE,QAAQ,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;AAAnJ,wBA8CC"}

package/dist/src/stream-muxer/spawner.js

@@ -1,39 +0,0 @@
-import { expect } from 'aegir/chai';
-import all from 'it-all';
-import drain from 'it-drain';
-import { duplexPair } from 'it-pair/duplex';
-import { pipe } from 'it-pipe';
-import pLimit from 'p-limit';
-import { Uint8ArrayList } from 'uint8arraylist';
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string';
-export default async (createMuxer, nStreams, nMsg, limit) => {
-    const [dialerSocket, listenerSocket] = duplexPair();
-    const msg = new Uint8ArrayList(uint8ArrayFromString('simple msg'));
-    const listener = await createMuxer({
-        direction: 'inbound',
-        onIncomingStream: (stream) => {
-            void pipe(stream, drain).then(async () => {
-                await stream.close();
-            })
-                .catch(err => { stream.abort(err); });
-        }
-    });
-    const dialer = await createMuxer({
-        direction: 'outbound'
-    });
-    void pipe(listenerSocket, listener, listenerSocket);
-    void pipe(dialerSocket, dialer, dialerSocket);
-    const spawnStream = async () => {
-        const stream = await dialer.newStream();
-        expect(stream).to.exist; // eslint-disable-line
-        const res = await pipe((async function* () {
-            for (let i = 0; i < nMsg; i++) {
-                yield msg;
-            }
-        }()), stream, async (source) => all(source));
-        expect(res).to.be.eql([]);
-    };
-    const limiter = pLimit(limit ?? Infinity);
-    await Promise.all(Array.from(Array(nStreams), async () => { await limiter(async () => { await spawnStream(); }); }));
-};
-//# sourceMappingURL=spawner.js.map

package/dist/src/stream-muxer/spawner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"spawner.js","sourceRoot":"","sources":["../../../src/stream-muxer/spawner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACnC,OAAO,GAAG,MAAM,QAAQ,CAAA;AACxB,OAAO,KAAK,MAAM,UAAU,CAAA;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC9B,OAAO,MAAM,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EAAE,UAAU,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAG5E,eAAe,KAAK,EAAE,WAA6D,EAAE,QAAgB,EAAE,IAAY,EAAE,KAAc,EAAiB,EAAE;IACpJ,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,GAAG,UAAU,EAA+B,CAAA;IAEhF,MAAM,GAAG,GAAG,IAAI,cAAc,CAAC,oBAAoB,CAAC,YAAY,CAAC,CAAC,CAAA;IAElE,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC;QACjC,SAAS,EAAE,SAAS;QACpB,gBAAgB,EAAE,CAAC,MAAM,EAAE,EAAE;YAC3B,KAAK,IAAI,CACP,MAAM,EACN,KAAK,CACN,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;gBAChB,MAAM,MAAM,CAAC,KAAK,EAAE,CAAA;YACtB,CAAC,CAAC;iBACC,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA,CAAC,CAAC,CAAC,CAAA;QACxC,CAAC;KACF,CAAC,CAAA;IACF,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC;QAC/B,SAAS,EAAE,UAAU;KACtB,CAAC,CAAA;IAEF,KAAK,IAAI,CAAC,cAAc,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAA;IACnD,KAAK,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,CAAC,CAAA;IAE7C,MAAM,WAAW,GAAG,KAAK,IAAmB,EAAE;QAC5C,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,SAAS,EAAE,CAAA;QACvC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,KAAK,CAAA,CAAC,sBAAsB;QAE9C,MAAM,GAAG,GAAG,MAAM,IAAI,CACpB,CAAC,KAAK,SAAU,CAAC;YACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC9B,MAAM,GAAG,CAAA;YACX,CAAC;QACH,CAAC,EAAE,CAAC,EACJ,MAAM,EACN,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAC9B,CAAA;QAED,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IAC3B,CAAC,CAAA;IAED,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,IAAI,QAAQ,CAAC,CAAA;IAEzC,MAAM,OAAO,CAAC,GAAG,CACf,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,KAAK,IAAI,EAAE,GAAG,MAAM,OAAO,CAAC,KAAK,IAAI,EAAE,GAAG,MAAM,WAAW,EAAE,CAAA,CAAC,CAAC,CAAC,CAAA,CAAC,CAAC,CAAC,CAChG,CAAA;AACH,CAAC,CAAA"}

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

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

package/src/matchers.ts

@@ -1,18 +0,0 @@
-import Sinon from 'sinon'
-import type { PeerId } from '@libp2p/interface'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { SinonMatcher } from 'sinon'
-
-/**
- * @deprecated PeerIds can be passed to sinon matchers directly
- */
-export function matchPeerId (peerId: PeerId): SinonMatcher {
-  return Sinon.match(p => p.toString() === peerId.toString())
-}
-
-/**
- * @deprecated Multiaddrs can be passed to sinon matchers directly
- */
-export function matchMultiaddr (ma: Multiaddr): SinonMatcher {
-  return Sinon.match(m => m.toString() === ma.toString())
-}

package/src/mocks/connection-manager.ts

@@ -1,216 +0,0 @@
-import { UnsupportedOperationError, isPeerId } from '@libp2p/interface'
-import { PeerMap } from '@libp2p/peer-collections'
-import { peerIdFromString } from '@libp2p/peer-id'
-import { isMultiaddr } from '@multiformats/multiaddr'
-import { connectionPair } from './connection.js'
-import type { PrivateKey, PeerId, ComponentLogger, Libp2pEvents, PendingDial, Connection, PubSub, Startable } from '@libp2p/interface'
-import type { ConnectionManager, Registrar } from '@libp2p/interface-internal'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { AbortOptions } from 'it-pushable'
-import type { TypedEventTarget } from 'main-event'
-
-export interface MockNetworkComponents {
-  peerId: PeerId
-  privateKey: PrivateKey
-  registrar: Registrar
-  connectionManager: ConnectionManager
-  events: TypedEventTarget<Libp2pEvents>
-  pubsub?: PubSub
-  logger: ComponentLogger
-}
-
-export 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 Error('Peer not found')
-  }
-
-  reset (): void {
-    this.components = []
-  }
-}
-
-export const mockNetwork = new MockNetwork()
-
-export interface MockConnectionManagerComponents {
-  peerId: PeerId
-  registrar: Registrar
-  events: TypedEventTarget<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
-  }
-
-  getMaxConnections (): number {
-    return 10_000
-  }
-
-  setMaxConnections (): void {
-
-  }
-
-  async openConnection (peerId: PeerId | Multiaddr | Multiaddr[], options?: AbortOptions): Promise<Connection> {
-    if (isMultiaddr(peerId)) {
-      throw new UnsupportedOperationError('Dialing multiaddrs not supported')
-    }
-
-    options?.signal?.throwIfAborted()
-
-    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> {
-    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 []
-  }
-
-  async isDialable (): Promise<boolean> {
-    return true
-  }
-}
-
-export function mockConnectionManager (components: MockConnectionManagerComponents): ConnectionManager {
-  return new MockConnectionManager(components)
-}

package/src/mocks/connection.ts

@@ -1,309 +0,0 @@
-import { ConnectionClosedError } from '@libp2p/interface'
-import { defaultLogger, logger } from '@libp2p/logger'
-import * as mss from '@libp2p/multistream-select'
-import { peerIdFromString } from '@libp2p/peer-id'
-import { closeSource } from '@libp2p/utils/close-source'
-import { duplexPair } from 'it-pair/duplex'
-import { pipe } from 'it-pipe'
-import { Uint8ArrayList } from 'uint8arraylist'
-import { mockMultiaddrConnection } from './multiaddr-connection.js'
-import { mockMuxer } from './muxer.js'
-import { mockRegistrar } from './registrar.js'
-import type { AbortOptions, ComponentLogger, Logger, MultiaddrConnection, Connection, Stream, Direction, ConnectionTimeline, ConnectionStatus, PeerId, StreamMuxer, StreamMuxerFactory, NewStreamOptions, ConnectionLimits } from '@libp2p/interface'
-import type { Registrar } from '@libp2p/interface-internal'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { Duplex, Source } from 'it-stream-types'
-
-export interface MockConnectionOptions {
-  direction?: Direction
-  registrar?: Registrar
-  muxerFactory?: StreamMuxerFactory
-  logger?: ComponentLogger
-}
-
-interface MockConnectionInit {
-  remoteAddr: Multiaddr
-  remotePeer: PeerId
-  direction: Direction
-  maConn: MultiaddrConnection
-  muxer: StreamMuxer
-  logger: ComponentLogger
-}
-
-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 limits?: ConnectionLimits
-  public log: Logger
-
-  private readonly muxer: StreamMuxer
-  private readonly maConn: MultiaddrConnection
-  private readonly logger: ComponentLogger
-
-  constructor (init: MockConnectionInit) {
-    const { remoteAddr, remotePeer, direction, maConn, muxer, logger } = 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.logger = logger
-    this.log = logger.forComponent(this.id)
-  }
-
-  async newStream (protocols: string | string[], options?: NewStreamOptions): 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 ConnectionClosedError('connection must be open to create streams')
-    }
-
-    options?.signal?.throwIfAborted()
-
-    const id = `${Math.random()}`
-    const stream = await this.muxer.newStream(id)
-    const result = await mss.select(stream, protocols, {
-      ...options,
-      log: this.logger.forComponent('libp2p:mock-connection:stream:mss:select')
-    })
-
-    stream.protocol = result.protocol
-    stream.direction = 'outbound'
-    stream.sink = result.stream.sink
-    stream.source = result.stream.source
-
-    this.streams.push(stream)
-
-    return stream
-  }
-
-  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'
-  const logger = opts.logger ?? defaultLogger()
-
-  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 log = logger.forComponent('libp2p:mock-muxer')
-
-  const muxer = muxerFactory.createStreamMuxer({
-    log,
-    direction,
-    onIncomingStream: (muxedStream) => {
-      try {
-        mss.handle(muxedStream, registrar.getProtocols(), {
-          log
-        })
-          .then(async ({ stream, protocol }) => {
-            log('%s: incoming stream opened on %s', direction, protocol)
-            muxedStream.protocol = protocol
-            muxedStream.sink = stream.sink
-            muxedStream.source = stream.source
-
-            connection.streams.push(muxedStream)
-            const { handler } = registrar.getHandler(protocol)
-
-            await handler({ connection, stream: muxedStream })
-          }).catch(err => {
-            log.error(err)
-            muxedStream.abort(err)
-          })
-      } catch (err: any) {
-        log.error(err)
-      }
-    },
-    onStreamEnd: (muxedStream) => {
-      connection.streams = connection.streams.filter(stream => stream.id !== muxedStream.id)
-    }
-  })
-
-  void pipe(
-    maConn, muxer, maConn
-  )
-
-  const connection = new MockConnection({
-    remoteAddr,
-    remotePeer,
-    direction,
-    maConn,
-    muxer,
-    logger
-  })
-
-  return connection
-}
-
-export interface StreamInit {
-  direction?: Direction
-  protocol?: string
-  id?: string
-}
-
-export function mockStream (stream: Duplex<AsyncGenerator<Uint8ArrayList>, Source<Uint8ArrayList | Uint8Array>, Promise<void>>, init: StreamInit = {}): Stream {
-  const id = `stream-${Date.now()}`
-  const log = logger(`libp2p:mock-stream:${id}`)
-
-  // ensure stream output is `Uint8ArrayList` as it would be from an actual
-  // Stream where everything is length-varint encoded
-  const originalSource = stream.source
-  stream.source = (async function * (): AsyncGenerator<Uint8ArrayList, any, unknown> {
-    for await (const buf of originalSource) {
-      if (buf instanceof Uint8Array) {
-        yield new Uint8ArrayList(buf)
-      } else {
-        yield buf
-      }
-    }
-  })()
-
-  const abortSinkController = new AbortController()
-  const originalSink = stream.sink.bind(stream)
-  stream.sink = async (source) => {
-    abortSinkController.signal.addEventListener('abort', () => {
-      closeSource(source, log)
-    })
-
-    await originalSink(source)
-  }
-
-  const mockStream: Stream = {
-    ...stream,
-    close: async (options) => {
-      await mockStream.closeRead(options)
-      await mockStream.closeWrite(options)
-    },
-    closeRead: async () => {
-      closeSource(originalSource, log)
-      mockStream.timeline.closeRead = Date.now()
-
-      if (mockStream.timeline.closeWrite != null) {
-        mockStream.timeline.close = Date.now()
-      }
-    },
-    closeWrite: async () => {
-      abortSinkController.abort()
-      mockStream.timeline.closeWrite = Date.now()
-
-      if (mockStream.timeline.closeRead != null) {
-        mockStream.timeline.close = Date.now()
-      }
-    },
-    abort: () => {
-      closeSource(originalSource, log)
-      mockStream.timeline.closeWrite = Date.now()
-      mockStream.timeline.closeRead = Date.now()
-      mockStream.timeline.close = Date.now()
-    },
-    direction: 'outbound',
-    protocol: '/foo/1.0.0',
-    timeline: {
-      open: Date.now()
-    },
-    metadata: {},
-    id: `stream-${Date.now()}`,
-    status: 'open',
-    readStatus: 'ready',
-    writeStatus: 'ready',
-    log: logger('mock-stream'),
-    ...init
-  }
-
-  return mockStream
-}
-
-export interface StreamPairInit {
-  duplex: Duplex<AsyncGenerator<Uint8ArrayList>, Source<Uint8ArrayList | Uint8Array>, Promise<void>>
-  init?: StreamInit
-}
-
-export function streamPair (a: StreamPairInit, b: StreamPairInit, init: StreamInit = {}): [Stream, Stream] {
-  return [
-    mockStream(a.duplex, {
-      direction: 'outbound',
-      ...init,
-      ...(a.init ?? {})
-    }),
-    mockStream(b.duplex, {
-      direction: 'inbound',
-      ...init,
-      ...(b.init ?? {})
-    })
-  ]
-}
-
-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 | Uint8ArrayList>()
-
-  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
-    })
-  ]
-}

package/src/mocks/duplex.ts

@@ -1,11 +0,0 @@
-import type { Duplex, Source } from 'it-stream-types'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-export function mockDuplex (): Duplex<AsyncGenerator<Uint8Array | Uint8ArrayList>, Source<Uint8Array | Uint8ArrayList>, Promise<void>> {
-  return {
-    source: (async function * () {
-      yield * []
-    }()),
-    sink: async () => {}
-  }
-}