@libp2p/interface-compliance-tests 1.0.5 → 1.1.0

package/dist/src/utils/mock-connection-gater.d.ts

@@ -0,0 +1,12 @@
+export declare function mockConnectionGater(): {
+    denyDialPeer: () => Promise<boolean>;
+    denyDialMultiaddr: () => Promise<boolean>;
+    denyInboundConnection: () => Promise<boolean>;
+    denyOutboundConnection: () => Promise<boolean>;
+    denyInboundEncryptedConnection: () => Promise<boolean>;
+    denyOutboundEncryptedConnection: () => Promise<boolean>;
+    denyInboundUpgradedConnection: () => Promise<boolean>;
+    denyOutboundUpgradedConnection: () => Promise<boolean>;
+    filterMultiaddrForPeer: () => Promise<boolean>;
+};
+//# sourceMappingURL=mock-connection-gater.d.ts.map

package/dist/src/utils/mock-connection-gater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-connection-gater.d.ts","sourceRoot":"","sources":["../../../src/utils/mock-connection-gater.ts"],"names":[],"mappings":"AACA,wBAAgB,mBAAmB;;;;;;;;;;EAYlC"}

package/dist/src/utils/mock-connection-gater.js

@@ -0,0 +1,14 @@
+export function mockConnectionGater() {
+    return {
+        denyDialPeer: async () => await Promise.resolve(false),
+        denyDialMultiaddr: async () => await Promise.resolve(false),
+        denyInboundConnection: async () => await Promise.resolve(false),
+        denyOutboundConnection: async () => await Promise.resolve(false),
+        denyInboundEncryptedConnection: async () => await Promise.resolve(false),
+        denyOutboundEncryptedConnection: async () => await Promise.resolve(false),
+        denyInboundUpgradedConnection: async () => await Promise.resolve(false),
+        denyOutboundUpgradedConnection: async () => await Promise.resolve(false),
+        filterMultiaddrForPeer: async () => await Promise.resolve(true)
+    };
+}
+//# sourceMappingURL=mock-connection-gater.js.map

package/dist/src/utils/mock-connection-gater.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-connection-gater.js","sourceRoot":"","sources":["../../../src/utils/mock-connection-gater.ts"],"names":[],"mappings":"AACA,MAAM,UAAU,mBAAmB;IACjC,OAAO;QACL,YAAY,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;QACtD,iBAAiB,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;QAC3D,qBAAqB,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;QAC/D,sBAAsB,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;QAChE,8BAA8B,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;QACxE,+BAA+B,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;QACzE,6BAA6B,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;QACvE,8BAA8B,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;QACxE,sBAAsB,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;KAChE,CAAA;AACH,CAAC"}

package/dist/src/utils/mock-connection.d.ts

@@ -0,0 +1,5 @@
+import type { MultiaddrConnection } from '@libp2p/interfaces/transport';
+import type { Connection } from '@libp2p/interfaces/connection';
+import type { Muxer } from '@libp2p/interfaces/stream-muxer';
+export declare function mockConnection(maConn: MultiaddrConnection, direction: 'inbound' | 'outbound', muxer: Muxer): Promise<Connection>;
+//# sourceMappingURL=mock-connection.d.ts.map

package/dist/src/utils/mock-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-connection.d.ts","sourceRoot":"","sources":["../../../src/utils/mock-connection.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AACvE,OAAO,KAAK,EAAE,UAAU,EAAoC,MAAM,+BAA+B,CAAA;AACjG,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAA;AAE5D,wBAAsB,cAAc,CAAE,MAAM,EAAE,mBAAmB,EAAE,SAAS,EAAE,SAAS,GAAG,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CA0DvI"}

package/dist/src/utils/mock-connection.js

@@ -0,0 +1,52 @@
+import { PeerId } from '@libp2p/peer-id';
+import { createEd25519PeerId } from '@libp2p/peer-id-factory';
+import { pipe } from 'it-pipe';
+export async function mockConnection(maConn, direction, muxer) {
+    const remoteAddr = maConn.remoteAddr;
+    const remotePeerIdStr = remoteAddr.getPeerId();
+    const remotePeer = remotePeerIdStr != null ? PeerId.fromString(remotePeerIdStr) : await createEd25519PeerId();
+    const streams = [];
+    let streamId = 0;
+    const registry = new Map();
+    void pipe(maConn, muxer, maConn);
+    return {
+        id: 'mock-connection',
+        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 = `${streamId++}`;
+            const stream = muxer.newStream(id);
+            const streamData = {
+                protocol: protocols[0],
+                stream
+            };
+            registry.set(id, streamData);
+            return streamData;
+        },
+        addStream: (stream, metadata) => {
+        },
+        removeStream: (id) => {
+            registry.delete(id);
+        },
+        close: async () => {
+            await maConn.close();
+        }
+    };
+}
+//# sourceMappingURL=mock-connection.js.map

package/dist/src/utils/mock-connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-connection.js","sourceRoot":"","sources":["../../../src/utils/mock-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAC7D,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAK9B,MAAM,CAAC,KAAK,UAAU,cAAc,CAAE,MAA2B,EAAE,SAAiC,EAAE,KAAY;IAChH,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAA;IACpC,MAAM,eAAe,GAAG,UAAU,CAAC,SAAS,EAAE,CAAA;IAC9C,MAAM,UAAU,GAAG,eAAe,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,MAAM,mBAAmB,EAAE,CAAA;IAE7G,MAAM,OAAO,GAAa,EAAE,CAAA;IAC5B,IAAI,QAAQ,GAAG,CAAC,CAAA;IAEhB,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAE,CAAA;IAE1B,KAAK,IAAI,CACP,MAAM,EAAE,KAAK,EAAE,MAAM,CACtB,CAAA;IAED,OAAO;QACL,EAAE,EAAE,iBAAiB;QACrB,UAAU;QACV,UAAU;QACV,IAAI,EAAE;YACJ,MAAM,EAAE,MAAM;YACd,SAAS;YACT,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,WAAW,EAAE,kBAAkB;YAC/B,UAAU,EAAE,qBAAqB;SAClC;QACD,QAAQ;QACR,IAAI,EAAE,EAAE;QACR,OAAO;QACP,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE;YAC7B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE;gBAC7B,SAAS,GAAG,CAAC,SAAS,CAAC,CAAA;aACxB;YAED,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;gBAC1B,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAA;aAChD;YAED,MAAM,EAAE,GAAG,GAAG,QAAQ,EAAE,EAAE,CAAA;YAC1B,MAAM,MAAM,GAAW,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC,CAAA;YAC1C,MAAM,UAAU,GAAmB;gBACjC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;gBACtB,MAAM;aACP,CAAA;YAED,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,UAAU,CAAC,CAAA;YAE5B,OAAO,UAAU,CAAA;QACnB,CAAC;QACD,SAAS,EAAE,CAAC,MAAc,EAAE,QAAkB,EAAE,EAAE;QAElD,CAAC;QACD,YAAY,EAAE,CAAC,EAAU,EAAE,EAAE;YAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;QACrB,CAAC;QACD,KAAK,EAAE,KAAK,IAAI,EAAE;YAChB,MAAM,MAAM,CAAC,KAAK,EAAE,CAAA;QACtB,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/src/utils/mock-multiaddr-connection.d.ts

@@ -0,0 +1,4 @@
+import type { MultiaddrConnection } from '@libp2p/interfaces/transport';
+import type { Duplex } from 'it-stream-types';
+export declare function mockMultiaddrConnection(source: Duplex<Uint8Array>): MultiaddrConnection;
+//# sourceMappingURL=mock-multiaddr-connection.d.ts.map

package/dist/src/utils/mock-multiaddr-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-multiaddr-connection.d.ts","sourceRoot":"","sources":["../../../src/utils/mock-multiaddr-connection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AACvE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAE7C,wBAAgB,uBAAuB,CAAE,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,GAAG,mBAAmB,CAaxF"}

package/dist/src/utils/mock-multiaddr-connection.js

@@ -0,0 +1,14 @@
+import { Multiaddr } from '@multiformats/multiaddr';
+export function mockMultiaddrConnection(source) {
+    const maConn = {
+        ...source,
+        async close() {
+        },
+        timeline: {
+            open: Date.now()
+        },
+        remoteAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4001')
+    };
+    return maConn;
+}
+//# sourceMappingURL=mock-multiaddr-connection.js.map

package/dist/src/utils/mock-multiaddr-connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-multiaddr-connection.js","sourceRoot":"","sources":["../../../src/utils/mock-multiaddr-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAInD,MAAM,UAAU,uBAAuB,CAAE,MAA0B;IACjE,MAAM,MAAM,GAAwB;QAClC,GAAG,MAAM;QACT,KAAK,CAAC,KAAK;QAEX,CAAC;QACD,QAAQ,EAAE;YACR,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE;SACjB;QACD,UAAU,EAAE,IAAI,SAAS,CAAC,yBAAyB,CAAC;KACrD,CAAA;IAED,OAAO,MAAM,CAAA;AACf,CAAC"}

package/dist/src/utils/mock-muxer.d.ts

@@ -0,0 +1,3 @@
+import type { Muxer } from '@libp2p/interfaces/stream-muxer';
+export declare function mockMuxer(): Muxer;
+//# sourceMappingURL=mock-muxer.d.ts.map

package/dist/src/utils/mock-muxer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-muxer.d.ts","sourceRoot":"","sources":["../../../src/utils/mock-muxer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAA;AAE5D,wBAAgB,SAAS,IAAK,KAAK,CAoClC"}

package/dist/src/utils/mock-muxer.js

@@ -0,0 +1,37 @@
+import { pair } from 'it-pair';
+import { pushable } from 'it-pushable';
+import drain from 'it-drain';
+export function mockMuxer() {
+    let streamId = 0;
+    let streams = [];
+    const p = pushable();
+    const muxer = {
+        source: p,
+        sink: async (source) => {
+            await drain(source);
+        },
+        get streams() {
+            return streams;
+        },
+        newStream: (name) => {
+            const echo = pair();
+            const id = `${streamId++}`;
+            const stream = {
+                id,
+                sink: echo.sink,
+                source: echo.source,
+                close: () => {
+                    streams = streams.filter(s => s !== stream);
+                },
+                abort: () => { },
+                reset: () => { },
+                timeline: {
+                    open: 0
+                }
+            };
+            return stream;
+        }
+    };
+    return muxer;
+}
+//# sourceMappingURL=mock-muxer.js.map

package/dist/src/utils/mock-muxer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-muxer.js","sourceRoot":"","sources":["../../../src/utils/mock-muxer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC9B,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,KAAK,MAAM,UAAU,CAAA;AAI5B,MAAM,UAAU,SAAS;IACvB,IAAI,QAAQ,GAAG,CAAC,CAAA;IAChB,IAAI,OAAO,GAAa,EAAE,CAAA;IAC1B,MAAM,CAAC,GAAG,QAAQ,EAAc,CAAA;IAEhC,MAAM,KAAK,GAAU;QACnB,MAAM,EAAE,CAAC;QACT,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;YACrB,MAAM,KAAK,CAAC,MAAM,CAAC,CAAA;QACrB,CAAC;QACD,IAAI,OAAO;YACT,OAAO,OAAO,CAAA;QAChB,CAAC;QACD,SAAS,EAAE,CAAC,IAAa,EAAE,EAAE;YAC3B,MAAM,IAAI,GAAG,IAAI,EAAc,CAAA;YAE/B,MAAM,EAAE,GAAG,GAAG,QAAQ,EAAE,EAAE,CAAA;YAC1B,MAAM,MAAM,GAAW;gBACrB,EAAE;gBACF,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,KAAK,EAAE,GAAG,EAAE;oBACV,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAA;gBAC7C,CAAC;gBACD,KAAK,EAAE,GAAG,EAAE,GAAE,CAAC;gBACf,KAAK,EAAE,GAAG,EAAE,GAAE,CAAC;gBACf,QAAQ,EAAE;oBACR,IAAI,EAAE,CAAC;iBACR;aACF,CAAA;YAED,OAAO,MAAM,CAAA;QACf,CAAC;KACF,CAAA;IAED,OAAO,KAAK,CAAA;AACd,CAAC"}

package/dist/src/utils/mock-upgrader.d.ts

@@ -0,0 +1,7 @@
+import type { Upgrader } from '@libp2p/interfaces/transport';
+import type { Muxer } from '@libp2p/interfaces/stream-muxer';
+export interface MockUpgraderOptions {
+    muxer?: Muxer;
+}
+export declare function mockUpgrader(options?: MockUpgraderOptions): Upgrader;
+//# sourceMappingURL=mock-upgrader.d.ts.map

package/dist/src/utils/mock-upgrader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-upgrader.d.ts","sourceRoot":"","sources":["../../../src/utils/mock-upgrader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAuB,MAAM,8BAA8B,CAAA;AACjF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAA;AAE5D,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,KAAK,CAAA;CACd;AAED,wBAAgB,YAAY,CAAE,OAAO,GAAE,mBAAwB,YAsB9D"}

package/dist/src/utils/mock-upgrader.js

@@ -0,0 +1,24 @@
+import { expect } from 'aegir/utils/chai.js';
+import { mockMuxer } from './mock-muxer.js';
+import { mockConnection } from './mock-connection.js';
+export function mockUpgrader(options = {}) {
+    const ensureProps = (multiaddrConnection) => {
+        ['sink', 'source', 'remoteAddr', 'timeline', 'close'].forEach(prop => {
+            expect(multiaddrConnection).to.have.property(prop);
+        });
+        return multiaddrConnection;
+    };
+    const muxer = options.muxer ?? mockMuxer();
+    const upgrader = {
+        async upgradeOutbound(multiaddrConnection) {
+            ensureProps(multiaddrConnection);
+            return await mockConnection(multiaddrConnection, 'outbound', muxer);
+        },
+        async upgradeInbound(multiaddrConnection) {
+            ensureProps(multiaddrConnection);
+            return await mockConnection(multiaddrConnection, 'inbound', muxer);
+        }
+    };
+    return upgrader;
+}
+//# sourceMappingURL=mock-upgrader.js.map

package/dist/src/utils/mock-upgrader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-upgrader.js","sourceRoot":"","sources":["../../../src/utils/mock-upgrader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAQrD,MAAM,UAAU,YAAY,CAAE,UAA+B,EAAE;IAC7D,MAAM,WAAW,GAAG,CAAC,mBAAwC,EAAE,EAAE;QAC/D,CAAC,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACnE,MAAM,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;QACpD,CAAC,CAAC,CAAA;QACF,OAAO,mBAAmB,CAAA;IAC5B,CAAC,CAAA;IAED,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,SAAS,EAAE,CAAA;IAE1C,MAAM,QAAQ,GAAa;QACzB,KAAK,CAAC,eAAe,CAAE,mBAAmB;YACxC,WAAW,CAAC,mBAAmB,CAAC,CAAA;YAChC,OAAO,MAAM,cAAc,CAAC,mBAAmB,EAAE,UAAU,EAAE,KAAK,CAAC,CAAA;QACrE,CAAC;QACD,KAAK,CAAC,cAAc,CAAE,mBAAmB;YACvC,WAAW,CAAC,mBAAmB,CAAC,CAAA;YAChC,OAAO,MAAM,cAAc,CAAC,mBAAmB,EAAE,SAAS,EAAE,KAAK,CAAC,CAAA;QACpE,CAAC;KACF,CAAA;IAED,OAAO,QAAQ,CAAA;AACjB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/interface-compliance-tests",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "Compliance tests for JS libp2p interfaces",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p-interfaces/tree/master/packages/libp2p-interface-compliance-tests#readme",
@@ -73,8 +73,12 @@
       "types": "./dist/src/stream-muxer/index.d.ts"
     },
     "./topology": {
-      "import": "./dist/src/topology/index.js",
-      "types": "./dist/src/topology/index.d.ts"
+      "import": "./dist/src/topology/topology.js",
+      "types": "./dist/src/topology/topology.d.ts"
+    },
+    "./topology/multicodec-toplogy": {
+      "import": "./dist/src/topology/multicodec-toplogy.js",
+      "types": "./dist/src/topology/multicodec-toplogy.d.ts"
     },
     "./transport": {
       "import": "./dist/src/transport/index.js",
@@ -84,6 +88,30 @@
       "import": "./dist/src/transport/utils/index.js",
       "types": "./dist/src/transport/utils/index.d.ts"
     },
+    "./utils/mock-connection": {
+      "import": "./dist/src/utils/mock-connection.js",
+      "types": "./dist/src/utils/mock-connection.d.ts"
+    },
+    "./utils/mock-connection-gater": {
+      "import": "./dist/src/utils/mock-connection-gater.js",
+      "types": "./dist/src/utils/mock-connection-gater.d.ts"
+    },
+    "./utils/mock-multiaddr-connection": {
+      "import": "./dist/src/utils/mock-multiaddr-connection.js",
+      "types": "./dist/src/utils/mock-multiaddr-connection.d.ts"
+    },
+    "./utils/mock-muxer": {
+      "import": "./dist/src/utils/mock-muxer.js",
+      "types": "./dist/src/utils/mock-muxer.d.ts"
+    },
+    "./utils/mock-peer-store": {
+      "import": "./dist/src/utils/mock-peer-store.js",
+      "types": "./dist/src/utils/mock-peer-store.d.ts"
+    },
+    "./utils/mock-upgrader": {
+      "import": "./dist/src/utils/mock-upgrader.js",
+      "types": "./dist/src/utils/mock-upgrader.d.ts"
+    },
     "./utils/peers": {
       "import": "./dist/src/utils/peers.js",
       "types": "./dist/src/utils/peers.d.ts"
@@ -190,13 +218,11 @@
     "test:electron-main": "npm run test -- -t electron-main"
   },
   "dependencies": {
-    "@libp2p/connection": "^1.0.0",
     "@libp2p/crypto": "^0.22.2",
     "@libp2p/interfaces": "^1.0.0",
     "@libp2p/peer-id": "^1.0.0",
     "@libp2p/peer-id-factory": "^1.0.0",
-    "@libp2p/pubsub": "^1.0.0",
-    "@libp2p/topology": "^1.0.0",
+    "@libp2p/pubsub": "^1.1.0",
     "@multiformats/multiaddr": "^10.1.1",
     "abortable-iterator": "^4.0.0",
     "aegir": "^36.1.3",
@@ -207,11 +233,12 @@
     "it-map": "^1.0.6",
     "it-pair": "^2.0.0",
     "it-pipe": "^2.0.2",
+    "it-pushable": "^2.0.1",
     "multiformats": "^9.4.10",
     "p-defer": "^4.0.0",
     "p-limit": "^4.0.0",
     "p-wait-for": "^4.1.0",
-    "sinon": "^12.0.1",
+    "sinon": "^13.0.0",
     "uint8arrays": "^3.0.0",
     "util": "^0.12.4"
   },

package/src/connection/connection.ts

@@ -19,9 +19,7 @@ export default (test: TestSetup<Connection>) => {
 
       it('should have properties set', () => {
         expect(connection.id).to.exist()
-        expect(connection.localPeer).to.exist()
         expect(connection.remotePeer).to.exist()
-        expect(connection.localAddr).to.exist()
         expect(connection.remoteAddr).to.exist()
         expect(connection.stat.status).to.equal('OPEN')
         expect(connection.stat.timeline.open).to.exist()

package/src/crypto/utils/index.ts

@@ -10,7 +10,6 @@ export function createMaConnPair (): [MultiaddrConnection, MultiaddrConnection]
     const output: MultiaddrConnection = {
       ...duplex,
       close: async () => {},
-      conn: {},
       remoteAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4001'),
       timeline: {
         open: Date.now()

package/src/stream-muxer/base-test.ts

@@ -10,10 +10,11 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { isValidTick } from '../transport/utils/index.js'
 import type { DeferredPromise } from 'p-defer'
 import type { TestSetup } from '../index.js'
-import type { Muxer, MuxerOptions, MuxedStream } from '@libp2p/interfaces/stream-muxer'
-import type { Source } from 'it-stream-types'
+import type { Stream } from '@libp2p/interfaces/connection'
+import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
+import type { Source, Duplex } from 'it-stream-types'
 
-async function close (stream: MuxedStream) {
+async function drainAndClose (stream: Duplex<Uint8Array>) {
   return await pipe([], stream, drain)
 }
 
@@ -22,8 +23,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
     it('Open a stream from the dialer', async () => {
       const p = duplexPair<Uint8Array>()
       const dialer = await common.setup()
-      const onStreamPromise: DeferredPromise<MuxedStream> = defer()
-      const onStreamEndPromise: DeferredPromise<MuxedStream> = defer()
+      const onStreamPromise: DeferredPromise<Stream> = defer()
+      const onStreamEndPromise: DeferredPromise<Stream> = defer()
 
       const listener = await common.setup({
         onStream: stream => {
@@ -34,18 +35,21 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         }
       })
 
-      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
-      void pipe(p[1], listener.newStream('/test/stream'), p[1])
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
 
       const conn = dialer.newStream()
       expect(dialer.streams).to.include(conn)
       expect(isValidTick(conn.timeline.open)).to.equal(true)
 
+      void drainAndClose(conn)
+
       const stream = await onStreamPromise.promise
       expect(isValidTick(stream.timeline.open)).to.equal(true)
       // Make sure the stream is being tracked
       expect(listener.streams).to.include(stream)
-      void close(stream)
+
+      void drainAndClose(stream)
 
       // Make sure stream is closed properly
       const endedStream = await onStreamEndPromise.promise
@@ -58,7 +62,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       // Make sure the stream is removed from tracking
       expect(isValidTick(endedStream.timeline.close)).to.equal(true)
 
-      await close(conn)
+      await drainAndClose(dialer)
+      await drainAndClose(listener)
 
       // ensure we have no streams left
       expect(dialer.streams).to.have.length(0)
@@ -67,7 +72,7 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
 
     it('Open a stream from the listener', async () => {
       const p = duplexPair<Uint8Array>()
-      const onStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
         onStream: stream => {
           onStreamPromise.resolve(stream)
@@ -76,24 +81,27 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
 
       const listener = await common.setup()
 
-      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
-      void pipe(p[1], listener.newStream('/test/stream'), p[1])
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
 
       const conn = listener.newStream()
 
+      void drainAndClose(conn)
+
       const stream = await onStreamPromise.promise
       expect(isValidTick(stream.timeline.open)).to.equal(true)
       expect(listener.streams).to.include(conn)
       expect(isValidTick(conn.timeline.open)).to.equal(true)
-      await close(stream)
+      void drainAndClose(stream)
 
-      await close(conn)
+      await drainAndClose(dialer)
+      await drainAndClose(listener)
     })
 
     it('Open a stream on both sides', async () => {
       const p = duplexPair<Uint8Array>()
-      const onDialerStreamPromise: DeferredPromise<MuxedStream> = defer()
-      const onListenerStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
+      const onListenerStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
         onStream: stream => {
           onDialerStreamPromise.resolve(stream)
@@ -105,27 +113,30 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         }
       })
 
-      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
-      void pipe(p[1], listener.newStream('/test/stream'), p[1])
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
 
       const listenerConn = listener.newStream()
       const dialerConn = dialer.newStream()
 
+      void drainAndClose(dialerConn)
+      void drainAndClose(listenerConn)
+
       const dialerStream = await onDialerStreamPromise.promise
       const listenerStream = await onListenerStreamPromise.promise
 
-      await close(dialerStream)
-      await close(listenerStream)
+      await drainAndClose(dialerStream)
+      await drainAndClose(listenerStream)
 
-      await close(dialerConn)
-      await close(listenerConn)
+      await drainAndClose(dialer)
+      await drainAndClose(listener)
     })
 
     it('Open a stream on one side, write, open a stream on the other side', async () => {
       const toString = (source: Source<Uint8Array>) => map(source, (u) => uint8ArrayToString(u))
       const p = duplexPair<Uint8Array>()
-      const onDialerStreamPromise: DeferredPromise<MuxedStream> = defer()
-      const onListenerStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
+      const onListenerStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
         onStream: stream => {
           onDialerStreamPromise.resolve(stream)
@@ -137,8 +148,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         }
       })
 
-      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
-      void pipe(p[1], listener.newStream('/test/stream'), p[1])
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
 
       const dialerConn = dialer.newStream()
       const listenerConn = listener.newStream()

package/src/stream-muxer/close-test.ts

@@ -4,9 +4,10 @@ import { duplexPair } from 'it-pair/duplex'
 import { abortableSource, abortableDuplex } from 'abortable-iterator'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import drain from 'it-drain'
+import { mockUpgrader, mockMultiaddrConnection } from '../transport/utils/index.js'
 import type { TestSetup } from '../index.js'
 import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
-import type { Connection } from '@libp2p/interfaces/connection'
+import { expect } from 'aegir/utils/chai.js'
 
 async function pause (ms: number) {
   return await new Promise(resolve => setTimeout(resolve, ms))
@@ -27,30 +28,13 @@ const infiniteRandom = {
 
 export default (common: TestSetup<Muxer, MuxerOptions>) => {
   describe('close', () => {
-    it('closing underlying socket closes streams (tcp)', async () => {
-      const mockConn = (muxer: Muxer): Connection => {
-        // @ts-expect-error not all Connection methods are implemented
-        const connection: Connection = {
-          newStream: async (multicodecs) => {
-            return {
-              protocol: multicodecs[0],
-              stream: muxer.newStream(`${multicodecs[0]}`)
-            }
-          }
+    it('closing underlying socket closes streams', async () => {
+      const muxer = await common.setup({
+        onStream: (stream) => {
+          void pipe(stream, stream)
         }
-
-        return connection
-      }
-
-      const mockUpgrade = async (maConn: any) => {
-        const muxer = await common.setup({
-          onStream: (stream) => {
-            void pipe(stream, stream)
-          }
-        })
-        pipe(maConn, muxer.newStream('/test/stream'), maConn)
-        return mockConn(muxer)
-      }
+      })
+      const upgrader = mockUpgrader({ muxer })
 
       const [local, remote] = duplexPair<Uint8Array>()
       const controller = new AbortController()
@@ -58,8 +42,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         returnOnAbort: true
       })
 
-      await mockUpgrade(abortableRemote)
-      const dialerConn = await mockUpgrade(local)
+      await upgrader.upgradeInbound(mockMultiaddrConnection(abortableRemote))
+      const dialerConn = await upgrader.upgradeOutbound(mockMultiaddrConnection(local))
 
       const s1 = await dialerConn.newStream([''])
       const s2 = await dialerConn.newStream([''])
@@ -73,6 +57,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       // test is complete when all muxed streams have closed
       await s1Result
       await s2Result
+
+      expect(muxer.streams).to.be.empty()
     })
 
     it('closing one of the muxed streams doesn\'t close others', async () => {
@@ -84,8 +70,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         onStream: async (stream) => await pipe(stream, stream)
       })
 
-      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
-      void pipe(p[1], listener.newStream('/test/stream'), p[1])
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
 
       const stream = dialer.newStream()
       const streams = Array.from(Array(5), () => dialer.newStream())

package/src/stream-muxer/index.ts

@@ -3,9 +3,9 @@ import closeTest from './close-test.js'
 import stressTest from './stress-test.js'
 import megaStressTest from './mega-stress-test.js'
 import type { TestSetup } from '../index.js'
-import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
 
-export default (common: TestSetup<Muxer>) => {
+export default (common: TestSetup<Muxer, MuxerOptions>) => {
   describe('interface-stream-muxer', () => {
     baseTest(common)
     closeTest(common)

package/src/stream-muxer/mega-stress-test.ts

@@ -1,4 +1,4 @@
-import spawn from './spawner'
+import spawn from './spawner.js'
 import type { TestSetup } from '../index.js'
 import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
 

package/src/stream-muxer/spawner.ts

@@ -25,8 +25,8 @@ export default async (createMuxer: (options?: MuxerOptions) => Promise<Muxer>, n
 
   const dialer = await createMuxer()
 
-  void pipe(listenerSocket, listener.newStream('/test/stream'), listenerSocket)
-  void pipe(dialerSocket, dialer.newStream('/test/stream'), dialerSocket)
+  void pipe(listenerSocket, listener, listenerSocket)
+  void pipe(dialerSocket, dialer, dialerSocket)
 
   const spawnStream = async () => {
     const stream = dialer.newStream()

package/src/stream-muxer/stress-test.ts

@@ -1,4 +1,4 @@
-import spawn from './spawner'
+import spawn from './spawner.js'
 import type { TestSetup } from '../index.js'
 import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
 

package/src/transport/dial-test.ts

@@ -49,7 +49,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       expect(upgradeSpy.callCount).to.equal(1)
       await expect(upgradeSpy.getCall(0).returnValue).to.eventually.equal(conn)
       expect(result.length).to.equal(1)
-      expect(result[0].toString()).to.equal('hey')
+      expect(result[0]).to.equalBytes(uint8ArrayFromString('hey'))
       await conn.close()
     })