@libp2p/interface-compliance-tests 3.0.5 → 3.0.7-05abd49f

package/package.json

@@ -1,24 +1,20 @@
 {
   "name": "@libp2p/interface-compliance-tests",
-  "version": "3.0.5",
+  "version": "3.0.7-05abd49f",
   "description": "Compliance tests for JS libp2p interfaces",
   "license": "Apache-2.0 OR MIT",
-  "homepage": "https://github.com/libp2p/js-libp2p-interfaces/tree/master/packages/interface-compliance-tests#readme",
+  "homepage": "https://github.com/libp2p/js-libp2p/tree/master/packages/interface-compliance-tests#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/libp2p/js-libp2p-interfaces.git"
+    "url": "git+https://github.com/libp2p/js-libp2p.git"
   },
   "bugs": {
-    "url": "https://github.com/libp2p/js-libp2p-interfaces/issues"
+    "url": "https://github.com/libp2p/js-libp2p/issues"
   },
   "keywords": [
     "interface",
     "libp2p"
   ],
-  "engines": {
-    "node": ">=16.0.0",
-    "npm": ">=7.0.0"
-  },
   "type": "module",
   "types": "./dist/src/index.d.ts",
   "typesVersions": {
@@ -48,13 +44,37 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     },
+    "./connection": {
+      "types": "./dist/src/connection/index.d.ts",
+      "import": "./dist/src/connection/index.js"
+    },
+    "./connection-encryption": {
+      "types": "./dist/src/connection-encryption/index.d.ts",
+      "import": "./dist/src/connection-encryption/index.js"
+    },
     "./is-valid-tick": {
       "types": "./dist/src/is-valid-tick.d.ts",
       "import": "./dist/src/is-valid-tick.js"
     },
+    "./mocks": {
+      "types": "./dist/src/mocks/index.d.ts",
+      "import": "./dist/src/mocks/index.js"
+    },
+    "./peer-discovery": {
+      "types": "./dist/src/peer-discovery/index.d.ts",
+      "import": "./dist/src/peer-discovery/index.js"
+    },
     "./peers": {
       "types": "./dist/src/peers.d.ts",
       "import": "./dist/src/peers.js"
+    },
+    "./stream-muxer": {
+      "types": "./dist/src/stream-muxer/index.d.ts",
+      "import": "./dist/src/stream-muxer/index.js"
+    },
+    "./transport": {
+      "types": "./dist/src/transport/index.d.ts",
+      "import": "./dist/src/transport/index.js"
     }
   },
   "eslintConfig": {
@@ -63,100 +83,51 @@
       "sourceType": "module"
     }
   },
-  "release": {
-    "branches": [
-      "master"
-    ],
-    "plugins": [
-      [
-        "@semantic-release/commit-analyzer",
-        {
-          "preset": "conventionalcommits",
-          "releaseRules": [
-            {
-              "breaking": true,
-              "release": "major"
-            },
-            {
-              "revert": true,
-              "release": "patch"
-            },
-            {
-              "type": "feat",
-              "release": "minor"
-            },
-            {
-              "type": "fix",
-              "release": "patch"
-            },
-            {
-              "type": "docs",
-              "release": "patch"
-            },
-            {
-              "type": "test",
-              "release": "patch"
-            },
-            {
-              "type": "deps",
-              "release": "patch"
-            },
-            {
-              "scope": "no-release",
-              "release": false
-            }
-          ]
-        }
-      ],
-      [
-        "@semantic-release/release-notes-generator",
-        {
-          "preset": "conventionalcommits",
-          "presetConfig": {
-            "types": [
-              {
-                "type": "feat",
-                "section": "Features"
-              },
-              {
-                "type": "fix",
-                "section": "Bug Fixes"
-              },
-              {
-                "type": "chore",
-                "section": "Trivial Changes"
-              },
-              {
-                "type": "docs",
-                "section": "Documentation"
-              },
-              {
-                "type": "deps",
-                "section": "Dependencies"
-              },
-              {
-                "type": "test",
-                "section": "Tests"
-              }
-            ]
-          }
-        }
-      ],
-      "@semantic-release/changelog",
-      "@semantic-release/npm",
-      "@semantic-release/github",
-      "@semantic-release/git"
-    ]
-  },
   "scripts": {
     "clean": "aegir clean",
     "lint": "aegir lint",
     "dep-check": "aegir dep-check",
     "build": "aegir build",
-    "release": "aegir release"
+    "test": "aegir test",
+    "test:chrome": "aegir test -t browser --cov",
+    "test:chrome-webworker": "aegir test -t webworker",
+    "test:firefox": "aegir test -t browser -- --browser firefox",
+    "test:firefox-webworker": "aegir test -t webworker -- --browser firefox",
+    "test:node": "aegir test -t node --cov",
+    "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "aegir": "^37.7.3"
+    "@libp2p/interface": "0.0.1-05abd49f",
+    "@libp2p/interface-internal": "0.0.1-05abd49f",
+    "@libp2p/logger": "2.1.1-05abd49f",
+    "@libp2p/multistream-select": "3.1.9-05abd49f",
+    "@libp2p/peer-collections": "3.0.2-05abd49f",
+    "@libp2p/peer-id": "2.0.3-05abd49f",
+    "@libp2p/peer-id-factory": "2.0.3-05abd49f",
+    "@multiformats/multiaddr": "^12.1.3",
+    "abortable-iterator": "^5.0.1",
+    "any-signal": "^4.1.1",
+    "delay": "^6.0.0",
+    "it-all": "^3.0.2",
+    "it-drain": "^3.0.2",
+    "it-handshake": "^4.1.3",
+    "it-map": "^3.0.3",
+    "it-ndjson": "^1.0.3",
+    "it-pair": "^2.0.6",
+    "it-pipe": "^3.0.1",
+    "it-pushable": "^3.1.3",
+    "it-stream-types": "^2.0.1",
+    "merge-options": "^3.0.4",
+    "p-defer": "^4.0.0",
+    "p-limit": "^4.0.0",
+    "p-wait-for": "^5.0.2",
+    "sinon": "^15.1.2",
+    "ts-sinon": "^2.0.2",
+    "uint8arraylist": "^2.4.3",
+    "uint8arrays": "^4.0.4"
+  },
+  "devDependencies": {
+    "aegir": "^39.0.10"
   },
   "typedoc": {
     "entryPoint": "./src/index.ts"

package/src/connection/index.ts

@@ -0,0 +1,184 @@
+import { expect } from 'aegir/chai'
+import sinon from 'sinon'
+import { stubInterface } from 'ts-sinon'
+import type { TestSetup } from '../index.js'
+import type { Connection, Stream } from '@libp2p/interface/connection'
+
+export default (test: TestSetup<Connection>): void => {
+  describe('connection', () => {
+    describe('open connection', () => {
+      let connection: Connection
+
+      beforeEach(async () => {
+        connection = await test.setup()
+      })
+
+      afterEach(async () => {
+        await connection.close()
+        await test.teardown()
+      })
+
+      it('should have properties set', () => {
+        expect(connection.id).to.exist()
+        expect(connection.remotePeer).to.exist()
+        expect(connection.remoteAddr).to.exist()
+        expect(connection.stat.status).to.equal('OPEN')
+        expect(connection.stat.timeline.open).to.exist()
+        expect(connection.stat.timeline.close).to.not.exist()
+        expect(connection.stat.direction).to.exist()
+        expect(connection.streams).to.eql([])
+        expect(connection.tags).to.eql([])
+      })
+
+      it('should get the metadata of an open connection', () => {
+        const stat = connection.stat
+
+        expect(stat.status).to.equal('OPEN')
+        expect(stat.direction).to.exist()
+        expect(stat.timeline.open).to.exist()
+        expect(stat.timeline.close).to.not.exist()
+      })
+
+      it('should return an empty array of streams', () => {
+        const streams = connection.streams
+
+        expect(streams).to.eql([])
+      })
+
+      it('should be able to create a new stream', async () => {
+        expect(connection.streams).to.be.empty()
+
+        const protocolToUse = '/echo/0.0.1'
+        const stream = await connection.newStream([protocolToUse])
+
+        expect(stream).to.have.nested.property('stat.protocol', protocolToUse)
+
+        const connStreams = connection.streams
+
+        expect(stream).to.exist()
+        expect(connStreams).to.exist()
+        expect(connStreams).to.have.lengthOf(1)
+        expect(connStreams[0]).to.equal(stream)
+      })
+    })
+
+    describe('close connection', () => {
+      let connection: Connection
+      let timelineProxy
+      const proxyHandler = {
+        set () {
+          // @ts-expect-error - TS fails to infer here
+          return Reflect.set(...arguments)
+        }
+      }
+
+      beforeEach(async () => {
+        timelineProxy = new Proxy({
+          open: Date.now() - 10,
+          upgraded: Date.now()
+        }, proxyHandler)
+
+        connection = await test.setup()
+        connection.stat.timeline = timelineProxy
+      })
+
+      afterEach(async () => {
+        await test.teardown()
+      })
+
+      it('should be able to close the connection after being created', async () => {
+        expect(connection.stat.timeline.close).to.not.exist()
+        await connection.close()
+
+        expect(connection.stat.timeline.close).to.exist()
+        expect(connection.stat.status).to.equal('CLOSED')
+      })
+
+      it('should be able to close the connection after opening a stream', async () => {
+        // Open stream
+        const protocol = '/echo/0.0.1'
+        await connection.newStream([protocol])
+
+        // Close connection
+        expect(connection.stat.timeline.close).to.not.exist()
+        await connection.close()
+
+        expect(connection.stat.timeline.close).to.exist()
+        expect(connection.stat.status).to.equal('CLOSED')
+      })
+
+      it('should properly track streams', async () => {
+        // Open stream
+        const protocol = '/echo/0.0.1'
+        const stream = await connection.newStream([protocol])
+        expect(stream).to.have.nested.property('stat.protocol', protocol)
+
+        // Close stream
+        stream.close()
+
+        expect(connection.streams.filter(s => s.id === stream.id)).to.be.empty()
+      })
+
+      it('should track outbound streams', async () => {
+        // Open stream
+        const protocol = '/echo/0.0.1'
+        const stream = await connection.newStream(protocol)
+        expect(stream).to.have.nested.property('stat.direction', 'outbound')
+      })
+
+      it.skip('should track inbound streams', async () => {
+        // Add an remotely opened stream
+        const stream = stubInterface<Stream>()
+        connection.addStream(stream)
+        expect(stream).to.have.property('direction', 'inbound')
+      })
+
+      it('should support a proxy on the timeline', async () => {
+        sinon.spy(proxyHandler, 'set')
+        expect(connection.stat.timeline.close).to.not.exist()
+
+        await connection.close()
+        // @ts-expect-error - fails to infer callCount
+        expect(proxyHandler.set.callCount).to.equal(1)
+        // @ts-expect-error - fails to infer getCall
+        const [obj, key, value] = proxyHandler.set.getCall(0).args
+        expect(obj).to.eql(connection.stat.timeline)
+        expect(key).to.equal('close')
+        expect(value).to.be.a('number').that.equals(connection.stat.timeline.close)
+      })
+
+      it('should fail to create a new stream if the connection is closing', async () => {
+        expect(connection.stat.timeline.close).to.not.exist()
+        const p = connection.close()
+
+        try {
+          const protocol = '/echo/0.0.1'
+          await connection.newStream([protocol])
+        } catch (err: any) {
+          expect(err).to.exist()
+          return
+        } finally {
+          await p
+        }
+
+        throw new Error('should fail to create a new stream if the connection is closing')
+      })
+
+      it('should fail to create a new stream if the connection is closed', async () => {
+        expect(connection.stat.timeline.close).to.not.exist()
+        await connection.close()
+
+        try {
+          const protocol = '/echo/0.0.1'
+          await connection.newStream([protocol])
+        } catch (err: any) {
+          expect(err).to.exist()
+          expect(err.code).to.equal('ERR_CONNECTION_CLOSED')
+          return
+        }
+
+        throw new Error('should fail to create a new stream if the connection is closing')
+      })
+    })
+  })
+}

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,23 @@
+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 () => {},
+      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,5 +1,5 @@
 
-export interface TestSetup<T, SetupArgs = {}> {
+export interface TestSetup<T, SetupArgs = Record<string, unknown>> {
   setup: (args?: SetupArgs) => Promise<T>
   teardown: () => Promise<void>
 }

package/src/is-valid-tick.ts

@@ -3,7 +3,7 @@
  * A tick is considered valid if it happened between now
  * and `ms` milliseconds ago
  */
-export function isValidTick (date?: number, ms: number = 5000) {
+export function isValidTick (date?: number, ms: number = 5000): boolean {
   if (date == null) {
     throw new Error('date must be a number')
   }

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)
+  }
+}