feat!: update libp2p interfaces (#1252)

BREAKING CHANGE: uses new single-issue libp2p interface modules

doc/CONFIGURATION.md

@@ -323,7 +323,7 @@ import { TCP } from '@libp2p/tcp'
 import { Mplex } from '@libp2p/mplex'
 import { Noise } from '@chainsafe/libp2p-noise'
 import { GossipSub } from 'libp2p-gossipsub'
-import { SignaturePolicy } from '@libp2p/interfaces/pubsub'
+import { SignaturePolicy } from '@libp2p/interface-pubsub'
 
 const node = await createLibp2p({
     transports: [

doc/migrations/v0.36-v.037.md

@@ -240,7 +240,7 @@ libp2p.pubsub.off('my-topic', handler)
 **After**
 
 ```js
-import type { Message } from '@libp2p/interfaces/pubsub'
+import type { Message } from '@libp2p/interface-pubsub'
 
 const handler = (event: CustomEvent<Message>) => {
   const message = event.detail

examples/delegated-routing/package.json

@@ -6,12 +6,12 @@
     "@chainsafe/libp2p-noise": "^6.2.0",
     "ipfs-core": "^0.14.1",
     "libp2p": "../../",
-    "@libp2p/delegated-content-routing": "^1.0.1",
+    "@libp2p/delegated-content-routing": "^2.0.1",
-    "@libp2p/delegated-peer-routing": "^1.0.1",
+    "@libp2p/delegated-peer-routing": "^2.0.1",
-    "@libp2p/kad-dht": "^1.0.9",
+    "@libp2p/kad-dht": "^2.0.0",
-    "@libp2p/mplex": "^1.0.4",
+    "@libp2p/mplex": "^2.0.0",
-    "@libp2p/webrtc-star": "^1.0.8",
+    "@libp2p/webrtc-star": "^2.0.0",
-    "@libp2p/websockets": "^1.0.7",
+    "@libp2p/websockets": "^2.0.0",
     "react": "^17.0.2",
     "react-dom": "^17.0.2",
     "react-scripts": "5.0.0"

examples/libp2p-in-the-browser/package.json

@@ -10,10 +10,10 @@
   "license": "ISC",
   "dependencies": {
     "@chainsafe/libp2p-noise": "^6.2.0",
-    "@libp2p/bootstrap": "^1.0.4",
+    "@libp2p/bootstrap": "^2.0.0",
-    "@libp2p/mplex": "^1.0.4",
+    "@libp2p/mplex": "^2.0.0",
-    "@libp2p/webrtc-star": "^1.0.8",
+    "@libp2p/webrtc-star": "^2.0.0",
-    "@libp2p/websockets": "^1.0.7",
+    "@libp2p/websockets": "^2.0.0",
     "libp2p": "../../"
   },
   "devDependencies": {

examples/package.json

@@ -9,8 +9,8 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@libp2p/pubsub-peer-discovery": "^5.0.2",
+    "@libp2p/pubsub-peer-discovery": "^6.0.0",
-    "@libp2p/floodsub": "^1.0.6",
+    "@libp2p/floodsub": "^2.0.0",
     "@nodeutils/defaults-deep": "^1.1.0",
     "execa": "^2.1.0",
     "fs-extra": "^8.1.0",

examples/webrtc-direct/package.json

@@ -9,10 +9,10 @@
   },
   "license": "ISC",
   "dependencies": {
-    "@libp2p/webrtc-direct": "^1.0.1",
+    "@libp2p/webrtc-direct": "^2.0.0",
     "@chainsafe/libp2p-noise": "^6.2.0",
-    "@libp2p/bootstrap": "^1.0.4",
+    "@libp2p/bootstrap": "^2.0.0",
-    "@libp2p/mplex": "^1.0.4",
+    "@libp2p/mplex": "^2.0.0",
     "libp2p": "../../",
     "wrtc": "^0.4.7"
   },

package.json

@@ -49,15 +49,19 @@
   ],
   "exports": {
     ".": {
+      "types": "./src/index.d.ts",
       "import": "./dist/src/index.js"
     },
     "./insecure": {
+      "types": "./dist/src/insecure/index.d.ts",
       "import": "./dist/src/insecure/index.js"
     },
     "./pnet": {
+      "types": "./dist/src/pnet/index.d.ts",
       "import": "./dist/src/pnet/index.js"
     },
     "./transport-manager": {
+      "types": "./dist/src/transport-manager.d.ts",
       "import": "./dist/src/transport-manager.js"
     }
   },
@@ -93,18 +97,34 @@
   },
   "dependencies": {
     "@achingbrain/nat-port-mapper": "^1.0.3",
-    "@libp2p/connection": "^2.0.2",
+    "@libp2p/components": "^1.0.0",
-    "@libp2p/crypto": "^0.22.11",
+    "@libp2p/connection": "^3.0.0",
-    "@libp2p/interfaces": "^2.0.2",
+    "@libp2p/crypto": "^1.0.0",
-    "@libp2p/logger": "^1.1.4",
+    "@libp2p/interface-address-manager": "^1.0.1",
-    "@libp2p/multistream-select": "^1.0.4",
+    "@libp2p/interface-connection": "^1.0.1",
+    "@libp2p/interface-connection-encrypter": "^1.0.2",
+    "@libp2p/interface-content-routing": "^1.0.1",
+    "@libp2p/interface-dht": "^1.0.0",
+    "@libp2p/interface-metrics": "^1.0.2",
+    "@libp2p/interface-peer-discovery": "^1.0.0",
+    "@libp2p/interface-peer-id": "^1.0.2",
+    "@libp2p/interface-peer-info": "^1.0.1",
+    "@libp2p/interface-peer-routing": "^1.0.0",
+    "@libp2p/interface-peer-store": "^1.0.0",
+    "@libp2p/interface-pubsub": "^1.0.1",
+    "@libp2p/interface-registrar": "^1.0.0",
+    "@libp2p/interface-stream-muxer": "^1.0.1",
+    "@libp2p/interface-transport": "^1.0.0",
+    "@libp2p/interfaces": "^3.0.2",
+    "@libp2p/logger": "^2.0.0",
+    "@libp2p/multistream-select": "^2.0.0",
     "@libp2p/peer-collections": "^1.0.2",
     "@libp2p/peer-id": "^1.1.10",
     "@libp2p/peer-id-factory": "^1.0.9",
-    "@libp2p/peer-record": "^1.0.8",
+    "@libp2p/peer-record": "^2.0.0",
-    "@libp2p/peer-store": "^1.0.10",
+    "@libp2p/peer-store": "^2.0.0",
     "@libp2p/tracked-map": "^1.0.5",
-    "@libp2p/utils": "^1.0.10",
+    "@libp2p/utils": "^2.0.0",
     "@multiformats/mafmt": "^11.0.2",
     "@multiformats/multiaddr": "^10.1.8",
     "abortable-iterator": "^4.0.2",
@@ -119,7 +139,7 @@
     "it-filter": "^1.0.3",
     "it-first": "^1.0.6",
     "it-foreach": "^0.1.1",
-    "it-handshake": "^3.0.1",
+    "it-handshake": "^4.0.0",
     "it-length-prefixed": "^7.0.1",
     "it-map": "^1.0.6",
     "it-merge": "^1.0.3",
@@ -146,22 +166,24 @@
   },
   "devDependencies": {
     "@chainsafe/libp2p-noise": "^6.2.0",
-    "@libp2p/bootstrap": "^1.0.4",
+    "@libp2p/bootstrap": "^2.0.0",
-    "@libp2p/daemon-client": "^1.0.2",
+    "@libp2p/daemon-client": "^2.0.0",
-    "@libp2p/daemon-server": "^1.0.2",
+    "@libp2p/daemon-server": "^2.0.0",
-    "@libp2p/delegated-content-routing": "^1.0.5",
+    "@libp2p/delegated-content-routing": "^2.0.0",
-    "@libp2p/delegated-peer-routing": "^1.0.5",
+    "@libp2p/delegated-peer-routing": "^2.0.0",
-    "@libp2p/floodsub": "^1.0.6",
+    "@libp2p/floodsub": "^2.0.0",
-    "@libp2p/interface-compliance-tests": "^2.0.3",
+    "@libp2p/interface-compliance-tests": "^3.0.1",
-    "@libp2p/interop": "^1.0.3",
+    "@libp2p/interface-connection-encrypter-compliance-tests": "^1.0.0",
-    "@libp2p/kad-dht": "^1.0.9",
+    "@libp2p/interface-mocks": "^1.0.1",
-    "@libp2p/mdns": "^1.0.5",
+    "@libp2p/interop": "^2.0.0",
-    "@libp2p/mplex": "^1.1.0",
+    "@libp2p/kad-dht": "^2.0.0",
-    "@libp2p/pubsub": "^1.2.18",
+    "@libp2p/mdns": "^2.0.0",
-    "@libp2p/tcp": "^1.0.9",
+    "@libp2p/mplex": "^2.0.0",
-    "@libp2p/topology": "^1.1.7",
+    "@libp2p/pubsub": "^2.0.0",
-    "@libp2p/webrtc-star": "^1.0.8",
+    "@libp2p/tcp": "^2.0.0",
-    "@libp2p/websockets": "^1.0.7",
+    "@libp2p/topology": "^2.0.0",
+    "@libp2p/webrtc-star": "^2.0.0",
+    "@libp2p/websockets": "^2.0.0",
     "@types/node-forge": "^1.0.0",
     "@types/p-fifo": "^1.0.0",
     "@types/varint": "^6.0.0",
@@ -173,7 +195,7 @@
     "go-libp2p": "^0.0.6",
     "into-stream": "^7.0.0",
     "ipfs-http-client": "^57.0.1",
-    "it-pushable": "^2.0.1",
+    "it-pushable": "^3.0.0",
     "it-to-buffer": "^2.0.2",
     "nock": "^13.0.3",
     "npm-run-all": "^4.1.5",

src/address-manager/index.ts

@@ -1,8 +1,8 @@
-import type { AddressManagerEvents } from '@libp2p/interfaces/address-manager'
+import type { AddressManagerEvents } from '@libp2p/interface-address-manager'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import { Multiaddr } from '@multiformats/multiaddr'
 import { peerIdFromString } from '@libp2p/peer-id'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 
 export interface AddressManagerInit {
   announceFilter?: AddressFilter

src/circuit/auto-relay.ts

@@ -10,10 +10,10 @@ import {
   HOP_METADATA_VALUE,
   RELAY_RENDEZVOUS_NS
 } from './constants.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
-import type { AddressSorter, PeerProtocolsChangeData } from '@libp2p/interfaces/peer-store'
+import type { AddressSorter, PeerProtocolsChangeData } from '@libp2p/interface-peer-store'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 import sort from 'it-sort'
 import all from 'it-all'
 import { pipe } from 'it-pipe'

src/circuit/circuit/hop.ts

@@ -7,11 +7,11 @@ import { pipe } from 'it-pipe'
 import { codes as Errors } from '../../errors.js'
 import { stop } from './stop.js'
 import { RELAY_CODEC } from '../multicodec.js'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
 import { peerIdFromBytes } from '@libp2p/peer-id'
 import type { Duplex } from 'it-stream-types'
 import type { Circuit } from '../transport.js'
-import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 
 const log = logger('libp2p:circuit:hop')
 

src/circuit/circuit/stop.ts

@@ -3,7 +3,7 @@ import { CircuitRelay as CircuitPB } from '../pb/index.js'
 import { RELAY_CODEC } from '../multicodec.js'
 import { StreamHandler } from './stream-handler.js'
 import { validateAddrs } from './utils.js'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
 import type { Duplex } from 'it-stream-types'
 
 const log = logger('libp2p:circuit:stop')

src/circuit/circuit/stream-handler.ts

@@ -2,7 +2,7 @@ import { logger } from '@libp2p/logger'
 import * as lp from 'it-length-prefixed'
 import { Handshake, handshake } from 'it-handshake'
 import { CircuitRelay } from '../pb/index.js'
-import type { Stream } from '@libp2p/interfaces/connection'
+import type { Stream } from '@libp2p/interface-connection'
 import type { Source } from 'it-stream-types'
 
 const log = logger('libp2p:circuit:stream-handler')

src/circuit/index.ts

@@ -10,9 +10,9 @@ import { namespaceToCid } from './utils.js'
 import {
   RELAY_RENDEZVOUS_NS
 } from './constants.js'
-import type { AddressSorter } from '@libp2p/interfaces/peer-store'
+import type { AddressSorter } from '@libp2p/interface-peer-store'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 
 const log = logger('libp2p:relay')
 

src/circuit/listener.ts

@@ -1,7 +1,7 @@
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
-import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerStore } from '@libp2p/interfaces/peer-store'
+import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { Listener } from '@libp2p/interfaces/transport'
+import type { Listener } from '@libp2p/interface-transport'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { Multiaddr } from '@multiformats/multiaddr'
 

src/circuit/transport.ts

@@ -10,13 +10,13 @@ import { createListener } from './listener.js'
 import { handleCanHop, handleHop, hop } from './circuit/hop.js'
 import { handleStop } from './circuit/stop.js'
 import { StreamHandler } from './circuit/stream-handler.js'
-import { symbol } from '@libp2p/interfaces/transport'
+import { symbol } from '@libp2p/interface-transport'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { Components, Initializable } from '@libp2p/interfaces/components'
+import { Components, Initializable } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
-import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
+import type { IncomingStreamData } from '@libp2p/interface-registrar'
-import type { Listener, Transport, CreateListenerOptions, ConnectionHandler } from '@libp2p/interfaces/transport'
+import type { Listener, Transport, CreateListenerOptions, ConnectionHandler } from '@libp2p/interface-transport'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
 
 const log = logger('libp2p:circuit')
 

src/connection-manager/auto-dialler.ts

@@ -7,7 +7,7 @@ import { pipe } from 'it-pipe'
 import filter from 'it-filter'
 import sort from 'it-sort'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 
 const log = logger('libp2p:connection-manager:auto-dialler')
 

src/connection-manager/dialer/auto-dialer.ts

@@ -1,6 +1,6 @@
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 import { logger } from '@libp2p/logger'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 import { TimeoutController } from 'timeout-abort-controller'
 
 const log = logger('libp2p:dialer:auto-dialer')

src/connection-manager/dialer/dial-request.ts

@@ -5,7 +5,7 @@ import { setMaxListeners } from 'events'
 import { codes } from '../../errors.js'
 import { logger } from '@libp2p/logger'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Dialer } from './index.js'
 

src/connection-manager/dialer/index.ts

@@ -18,16 +18,16 @@ import {
   MAX_PER_PEER_DIALS,
   MAX_ADDRS_TO_DIAL
 } from '../../constants.js'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { getPeer } from '../../get-peer.js'
 import sort from 'it-sort'
-import { Components, Initializable } from '@libp2p/interfaces/components'
+import { Components, Initializable } from '@libp2p/components'
 import map from 'it-map'
-import type { AddressSorter } from '@libp2p/interfaces/peer-store'
+import type { AddressSorter } from '@libp2p/interface-peer-store'
-import type { ComponentMetricsTracker } from '@libp2p/interfaces/metrics'
+import type { ComponentMetricsTracker } from '@libp2p/interface-metrics'
 
 const log = logger('libp2p:dialer')
 

src/connection-manager/index.ts

@@ -9,14 +9,14 @@ import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import type { Startable } from '@libp2p/interfaces/startable'
 import { trackedMap } from '@libp2p/tracked-map'
 import { codes } from '../errors.js'
-import { isPeerId, PeerId } from '@libp2p/interfaces/peer-id'
+import { isPeerId, PeerId } from '@libp2p/interface-peer-id'
 import { setMaxListeners } from 'events'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
-import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import { Components, Initializable } from '@libp2p/interfaces/components'
+import { Components, Initializable } from '@libp2p/components'
-import * as STATUS from '@libp2p/interfaces/connection/status'
+import * as STATUS from '@libp2p/interface-connection/status'
 import { Dialer } from './dialer/index.js'
-import type { AddressSorter } from '@libp2p/interfaces/peer-store'
+import type { AddressSorter } from '@libp2p/interface-peer-store'
 import type { Resolver } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:connection-manager')

src/content-routing/index.ts

@@ -8,11 +8,11 @@ import {
 import drain from 'it-drain'
 import merge from 'it-merge'
 import { pipe } from 'it-pipe'
-import type { ContentRouting } from '@libp2p/interfaces/content-routing'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { CID } from 'multiformats/cid'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 
 export interface CompoundContentRoutingInit {
   routers: ContentRouting[]

src/content-routing/utils.ts

@@ -2,8 +2,8 @@ import errCode from 'err-code'
 import filter from 'it-filter'
 import map from 'it-map'
 import type { Source } from 'it-stream-types'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { PeerStore } from '@libp2p/interfaces/peer-store'
+import type { PeerStore } from '@libp2p/interface-peer-store'
 
 /**
  * Store the multiaddrs from every peer in the passed peer store

src/dht/dht-content-routing.ts

@@ -1,7 +1,7 @@
 import drain from 'it-drain'
 import errCode from 'err-code'
-import type { DHT } from '@libp2p/interfaces/dht'
+import type { DHT } from '@libp2p/interface-dht'
-import type { ContentRouting } from '@libp2p/interfaces/content-routing'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { CID } from 'multiformats/cid'
 import type { AbortOptions } from '@libp2p/interfaces'
 

src/dht/dht-peer-routing.ts

@@ -1,8 +1,8 @@
 import errCode from 'err-code'
 import { messages, codes } from '../errors.js'
-import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
+import type { PeerRouting } from '@libp2p/interface-peer-routing'
-import type { DHT } from '@libp2p/interfaces/dht'
+import type { DHT } from '@libp2p/interface-dht'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { AbortOptions } from '@libp2p/interfaces'
 
 /**

src/dht/dummy-dht.ts

@@ -1,9 +1,9 @@
-import type { DualDHT, QueryEvent, SingleDHT } from '@libp2p/interfaces/dht'
+import type { DualDHT, QueryEvent, SingleDHT } from '@libp2p/interface-dht'
-import type { PeerDiscoveryEvents } from '@libp2p/interfaces/peer-discovery'
+import type { PeerDiscoveryEvents } from '@libp2p/interface-peer-discovery'
 import errCode from 'err-code'
 import { messages, codes } from '../errors.js'
 import { EventEmitter } from '@libp2p/interfaces/events'
-import { symbol } from '@libp2p/interfaces/peer-discovery'
+import { symbol } from '@libp2p/interface-peer-discovery'
 
 export class DummyDHT extends EventEmitter<PeerDiscoveryEvents> implements DualDHT {
   get [symbol] (): true {

src/fetch/index.ts

@@ -5,11 +5,11 @@ import * as lp from 'it-length-prefixed'
 import { FetchRequest, FetchResponse } from './pb/proto.js'
 import { handshake } from 'it-handshake'
 import { PROTOCOL_NAME, PROTOCOL_VERSION } from './constants.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Stream } from '@libp2p/interfaces/connection'
+import type { Stream } from '@libp2p/interface-connection'
-import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
+import type { IncomingStreamData } from '@libp2p/interface-registrar'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Duplex } from 'it-stream-types'
 import { abortableDuplex } from 'abortable-iterator'

src/get-peer.ts

@@ -2,9 +2,9 @@ import { peerIdFromString } from '@libp2p/peer-id'
 import { Multiaddr } from '@multiformats/multiaddr'
 import errCode from 'err-code'
 import { codes } from './errors.js'
-import { isPeerId } from '@libp2p/interfaces/peer-id'
+import { isPeerId } from '@libp2p/interface-peer-id'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 
 function peerIdFromMultiaddr (ma: Multiaddr) {
   const idStr = ma.getPeerId()

src/identify/index.ts

@@ -18,11 +18,11 @@ import {
   MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION
 } from './consts.js'
 import { codes } from '../errors.js'
-import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
+import type { IncomingStreamData } from '@libp2p/interface-registrar'
-import type { Connection, Stream } from '@libp2p/interfaces/connection'
+import type { Connection, Stream } from '@libp2p/interface-connection'
 import type { Startable } from '@libp2p/interfaces/startable'
 import { peerIdFromKeys } from '@libp2p/peer-id'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 import { TimeoutController } from 'timeout-abort-controller'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { abortableDuplex } from 'abortable-iterator'
@@ -79,8 +79,6 @@ export class IdentifyService implements Startable {
     this.started = false
     this.init = init
 
-    this.handleMessage = this.handleMessage.bind(this)
-
     this.identifyProtocolStr = `/${init.protocolPrefix}/${MULTICODEC_IDENTIFY_PROTOCOL_NAME}/${MULTICODEC_IDENTIFY_PROTOCOL_VERSION}`
     this.identifyPushProtocolStr = `/${init.protocolPrefix}/${MULTICODEC_IDENTIFY_PUSH_PROTOCOL_NAME}/${MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION}`
 
@@ -127,11 +125,13 @@ export class IdentifyService implements Startable {
     await this.components.getPeerStore().metadataBook.setValue(this.components.getPeerId(), 'AgentVersion', uint8ArrayFromString(this.host.agentVersion))
     await this.components.getPeerStore().metadataBook.setValue(this.components.getPeerId(), 'ProtocolVersion', uint8ArrayFromString(this.host.protocolVersion))
 
-    await this.components.getRegistrar().handle([
+    await this.components.getRegistrar().handle(this.identifyProtocolStr, (data) => {
-      this.identifyProtocolStr,
+      void this._handleIdentify(data).catch(err => {
-      this.identifyPushProtocolStr
+        log.error(err)
-    ], (data) => {
+      })
-      void this.handleMessage(data)?.catch(err => {
+    })
+    await this.components.getRegistrar().handle(this.identifyPushProtocolStr, (data) => {
+      void this._handlePush(data).catch(err => {
         log.error(err)
       })
     })
@@ -353,22 +353,6 @@ export class IdentifyService implements Startable {
     // this.components.getAddressManager().addObservedAddr(observedAddr)
   }
 
-  /**
-   * A handler to register with Libp2p to process identify messages
-   */
-  handleMessage (data: IncomingStreamData) {
-    const { protocol } = data
-
-    switch (protocol) {
-      case this.identifyProtocolStr:
-        return this._handleIdentify(data)
-      case this.identifyPushProtocolStr:
-        return this._handlePush(data)
-      default:
-        log.error('cannot handle unknown protocol %s', protocol)
-    }
-  }
-
   /**
    * Sends the `Identify` response with the Signed Peer Record
    * to the requesting peer over the given `connection`

src/index.ts

@@ -5,23 +5,23 @@ import type { Startable } from '@libp2p/interfaces/startable'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { FaultTolerance } from './transport-manager.js'
 import type { IdentifyServiceInit } from './identify/index.js'
-import type { DualDHT } from '@libp2p/interfaces/dht'
+import type { DualDHT } from '@libp2p/interface-dht'
 import type { Datastore } from 'interface-datastore'
-import type { PeerStore, PeerStoreInit } from '@libp2p/interfaces/peer-store'
+import type { PeerStore, PeerStoreInit } from '@libp2p/interface-peer-store'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { AutoRelayConfig, RelayAdvertiseConfig } from './circuit/index.js'
-import type { PeerDiscovery } from '@libp2p/interfaces/peer-discovery'
+import type { PeerDiscovery } from '@libp2p/interface-peer-discovery'
-import type { Connection, ConnectionGater, ConnectionProtector, ProtocolStream } from '@libp2p/interfaces/connection'
+import type { Connection, ConnectionGater, ConnectionProtector, ProtocolStream } from '@libp2p/interface-connection'
-import type { Transport } from '@libp2p/interfaces/transport'
+import type { Transport } from '@libp2p/interface-transport'
-import type { StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
+import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
-import type { ConnectionEncrypter } from '@libp2p/interfaces/connection-encrypter'
+import type { ConnectionEncrypter } from '@libp2p/interface-connection-encrypter'
-import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
+import type { PeerRouting } from '@libp2p/interface-peer-routing'
-import type { ContentRouting } from '@libp2p/interfaces/content-routing'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { PubSub } from '@libp2p/interfaces/pubsub'
+import type { PubSub } from '@libp2p/interface-pubsub'
-import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
+import type { Registrar, StreamHandler } from '@libp2p/interface-registrar'
-import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { Metrics, MetricsInit } from '@libp2p/interfaces/metrics'
+import type { Metrics, MetricsInit } from '@libp2p/interface-metrics'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { KeyChain } from './keychain/index.js'
 import type { ConnectionManagerInit } from './connection-manager/index.js'
 import type { PingServiceInit } from './ping/index.js'

src/insecure/index.ts

@@ -1,11 +1,11 @@
 import { logger } from '@libp2p/logger'
 import { handshake } from 'it-handshake'
 import * as lp from 'it-length-prefixed'
-import { UnexpectedPeerError, InvalidCryptoExchangeError } from '@libp2p/interfaces/connection-encrypter/errors'
+import { UnexpectedPeerError, InvalidCryptoExchangeError } from '@libp2p/interface-connection-encrypter/errors'
 import { Exchange, KeyType } from './pb/proto.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
-import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interfaces/connection-encrypter'
+import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
 import type { Duplex } from 'it-stream-types'
 
 const log = logger('libp2p:plaintext')

src/keychain/index.ts

@@ -10,8 +10,8 @@ import { codes } from '../errors.js'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { generateKeyPair, importKey, unmarshalPrivateKey } from '@libp2p/crypto/keys'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 import { pbkdf2, randomBytes } from '@libp2p/crypto'
 
 const log = logger('libp2p:keychain')

src/libp2p.ts

@@ -27,25 +27,25 @@ import { DHTPeerRouting } from './dht/dht-peer-routing.js'
 import { PersistentPeerStore } from '@libp2p/peer-store'
 import { DHTContentRouting } from './dht/dht-content-routing.js'
 import { AutoDialer } from './connection-manager/dialer/auto-dialer.js'
-import { Initializable, Components, isInitializable } from '@libp2p/interfaces/components'
+import { Initializable, Components, isInitializable } from '@libp2p/components'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
-import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
+import type { PeerRouting } from '@libp2p/interface-peer-routing'
-import type { ContentRouting } from '@libp2p/interfaces/content-routing'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { PubSub } from '@libp2p/interfaces/pubsub'
+import type { PubSub } from '@libp2p/interface-pubsub'
-import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
+import type { Registrar, StreamHandler } from '@libp2p/interface-registrar'
-import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { Libp2p, Libp2pEvents, Libp2pInit, Libp2pOptions } from './index.js'
 import { validateConfig } from './config.js'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
-import type { PeerStore } from '@libp2p/interfaces/peer-store'
+import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { DualDHT } from '@libp2p/interfaces/dht'
+import type { DualDHT } from '@libp2p/interface-dht'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import errCode from 'err-code'
 import { unmarshalPublicKey } from '@libp2p/crypto/keys'
-import type { Metrics } from '@libp2p/interfaces/metrics'
+import type { Metrics } from '@libp2p/interface-metrics'
 import { DummyDHT } from './dht/dummy-dht.js'
 import { DummyPubSub } from './pubsub/dummy-pubsub.js'
 import { PeerSet } from '@libp2p/peer-collections'
@@ -491,11 +491,27 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   }
 
   async handle (protocols: string | string[], handler: StreamHandler): Promise<void> {
-    return await this.components.getRegistrar().handle(protocols, handler)
+    if (!Array.isArray(protocols)) {
+      protocols = [protocols]
+    }
+
+    await Promise.all(
+      protocols.map(async protocol => {
+        await this.components.getRegistrar().handle(protocol, handler)
+      })
+    )
   }
 
   async unhandle (protocols: string[] | string): Promise<void> {
-    return await this.components.getRegistrar().unhandle(protocols)
+    if (!Array.isArray(protocols)) {
+      protocols = [protocols]
+    }
+
+    await Promise.all(
+      protocols.map(async protocol => {
+        await this.components.getRegistrar().unhandle(protocol)
+      })
+    )
   }
 
   /**

src/metrics/index.ts

@@ -3,8 +3,8 @@ import each from 'it-foreach'
 import LRU from 'hashlru'
 import { METRICS as defaultOptions } from '../constants.js'
 import { DefaultStats, StatsInit } from './stats.js'
-import type { ComponentMetricsUpdate, Metrics, Stats, TrackStreamOptions } from '@libp2p/interfaces/metrics'
+import type { ComponentMetricsUpdate, Metrics, Stats, TrackStreamOptions } from '@libp2p/interface-metrics'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { Duplex } from 'it-stream-types'
 

src/metrics/moving-average.ts

@@ -1,4 +1,4 @@
-import type { MovingAverage } from '@libp2p/interfaces/metrics'
+import type { MovingAverage } from '@libp2p/interface-metrics'
 
 export class DefaultMovingAverage {
   public movingAverage: number

src/metrics/stats.ts

@@ -2,7 +2,7 @@ import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import { createMovingAverage } from './moving-average.js'
 // @ts-expect-error no types
 import retimer from 'retimer'
-import type { MovingAverages, Stats, TransferStats } from '@libp2p/interfaces/metrics'
+import type { MovingAverages, Stats, TransferStats } from '@libp2p/interface-metrics'
 
 export interface StatsEvents {
   'update': CustomEvent<TransferStats>

src/nat-manager.ts

@@ -8,7 +8,7 @@ import errCode from 'err-code'
 import { codes } from './errors.js'
 import { isLoopback } from '@libp2p/utils/multiaddr/is-loopback'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 
 const log = logger('libp2p:nat')
 const DEFAULT_TTL = 7200

src/peer-record-updater.ts

@@ -1,5 +1,5 @@
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 import type { Startable } from '@libp2p/interfaces/startable'
 import { logger } from '@libp2p/logger'
 import { protocols } from '@multiformats/multiaddr'

src/peer-routing.ts

@@ -18,12 +18,12 @@ import {
 // @ts-expect-error module with no types
 } from 'set-delayed-interval'
 import { setMaxListeners } from 'events'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
+import type { PeerRouting } from '@libp2p/interface-peer-routing'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 
 const log = logger('libp2p:peer-routing')
 

src/ping/index.ts

@@ -6,10 +6,10 @@ import { pipe } from 'it-pipe'
 import first from 'it-first'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { PROTOCOL_NAME, PING_LENGTH, PROTOCOL_VERSION } from './constants.js'
-import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
+import type { IncomingStreamData } from '@libp2p/interface-registrar'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Duplex } from 'it-stream-types'
 import { abortableDuplex } from 'abortable-iterator'

src/pnet/index.ts

@@ -12,8 +12,7 @@ import {
 } from './crypto.js'
 import { handshake } from 'it-handshake'
 import { NONCE_LENGTH } from './key-generator.js'
-import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
+import type { ConnectionProtector, MultiaddrConnection } from '@libp2p/interface-connection'
-import type { ConnectionProtector } from '@libp2p/interfaces/connection'
 
 const log = logger('libp2p:pnet')
 

src/pubsub/dummy-pubsub.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from '@libp2p/interfaces/events'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PublishResult, PubSub, PubSubEvents, StrictNoSign, StrictSign } from '@libp2p/interfaces/pubsub'
+import type { PublishResult, PubSub, PubSubEvents, StrictNoSign, StrictSign } from '@libp2p/interface-pubsub'
 import errCode from 'err-code'
 import { messages, codes } from '../errors.js'
 

src/registrar.ts

@@ -1,30 +1,20 @@
 import { logger } from '@libp2p/logger'
 import errCode from 'err-code'
 import { codes } from './errors.js'
-import { isTopology, Topology } from '@libp2p/interfaces/topology'
+import { isTopology, StreamHandlerOptions, StreamHandlerRecord } from '@libp2p/interface-registrar'
-import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
+import type { Registrar, StreamHandler, Topology } from '@libp2p/interface-registrar'
-import type { PeerProtocolsChangeData } from '@libp2p/interfaces/peer-store'
+import type { PeerProtocolsChangeData } from '@libp2p/interface-peer-store'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 
 const log = logger('libp2p:registrar')
 
-function supportsProtocol (peerProtocols: string[], topologyProtocols: string[]) {
-  for (const peerProtocol of peerProtocols) {
-    if (topologyProtocols.includes(peerProtocol)) {
-      return true
-    }
-  }
-
-  return false
-}
-
 /**
  * Responsible for notifying registered protocols of events in the network.
  */
 export class DefaultRegistrar implements Registrar {
-  private readonly topologies: Map<string, { topology: Topology, protocols: string[] }>
+  private readonly topologies: Map<string, Map<string, Topology>>
-  private readonly handlers: Map<string, StreamHandler>
+  private readonly handlers: Map<string, StreamHandlerRecord>
   private readonly components: Components
 
   constructor (components: Components) {
@@ -42,17 +32,10 @@ export class DefaultRegistrar implements Registrar {
   }
 
   getProtocols () {
-    const protocols = new Set<string>()
+    return Array.from(new Set<string>([
-
+      ...this.topologies.keys(),
-    for (const topology of this.topologies.values()) {
+      ...this.handlers.keys()
-      topology.protocols.forEach(protocol => protocols.add(protocol))
+    ])).sort()
-    }
-
-    for (const protocol of this.handlers.keys()) {
-      protocols.add(protocol)
-    }
-
-    return Array.from(protocols).sort()
   }
 
   getHandler (protocol: string) {
@@ -66,33 +49,32 @@ export class DefaultRegistrar implements Registrar {
   }
 
   getTopologies (protocol: string) {
-    const output: Topology[] = []
+    const topologies = this.topologies.get(protocol)
 
-    for (const { topology, protocols } of this.topologies.values()) {
+    if (topologies == null) {
-      if (protocols.includes(protocol)) {
+      return []
-        output.push(topology)
-      }
     }
 
-    return output
+    return [
+      ...topologies.values()
+    ]
   }
 
   /**
    * Registers the `handler` for each protocol
    */
-  async handle (protocols: string | string[], handler: StreamHandler): Promise<void> {
+  async handle (protocol: string, handler: StreamHandler, options: StreamHandlerOptions = { maxConcurrentStreams: 1 }): Promise<void> {
-    const protocolList = Array.isArray(protocols) ? protocols : [protocols]
+    if (this.handlers.has(protocol)) {
-
+      throw errCode(new Error(`Handler already registered for protocol ${protocol}`), codes.ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED)
-    for (const protocol of protocolList) {
-      if (this.handlers.has(protocol)) {
-        throw errCode(new Error(`Handler already registered for protocol ${protocol}`), codes.ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED)
-      }
-
-      this.handlers.set(protocol, handler)
     }
 
+    this.handlers.set(protocol, {
+      handler,
+      options
+    })
+
     // Add new protocols to self protocols in the Protobook
-    await this.components.getPeerStore().protoBook.add(this.components.getPeerId(), protocolList)
+    await this.components.getPeerStore().protoBook.add(this.components.getPeerId(), [protocol])
   }
 
   /**
@@ -113,7 +95,7 @@ export class DefaultRegistrar implements Registrar {
   /**
    * Register handlers for a set of multicodecs given
    */
-  async register (protocols: string | string[], topology: Topology): Promise<string> {
+  async register (protocol: string, topology: Topology): Promise<string> {
     if (!isTopology(topology)) {
       log.error('topology must be an instance of interfaces/topology')
       throw errCode(new Error('topology must be an instance of interfaces/topology'), codes.ERR_INVALID_PARAMETERS)
@@ -122,10 +104,14 @@ export class DefaultRegistrar implements Registrar {
     // Create topology
     const id = `${(Math.random() * 1e9).toString(36)}${Date.now()}`
 
-    this.topologies.set(id, {
+    let topologies = this.topologies.get(protocol)
-      topology,
+
-      protocols: Array.isArray(protocols) ? protocols : [protocols]
+    if (topologies == null) {
-    })
+      topologies = new Map<string, Topology>()
+      this.topologies.set(protocol, topologies)
+    }
+
+    topologies.set(id, topology)
 
     // Set registrar
     await topology.setRegistrar(this)
@@ -137,7 +123,15 @@ export class DefaultRegistrar implements Registrar {
    * Unregister topology
    */
   unregister (id: string) {
-    this.topologies.delete(id)
+    for (const [protocol, topologies] of this.topologies.entries()) {
+      if (topologies.has(id)) {
+        topologies.delete(id)
+
+        if (topologies.size === 0) {
+          this.topologies.delete(protocol)
+        }
+      }
+    }
   }
 
   /**
@@ -148,8 +142,15 @@ export class DefaultRegistrar implements Registrar {
 
     void this.components.getPeerStore().protoBook.get(connection.remotePeer)
       .then(peerProtocols => {
-        for (const { topology, protocols } of this.topologies.values()) {
+        for (const protocol of peerProtocols) {
-          if (supportsProtocol(peerProtocols, protocols)) {
+          const topologies = this.topologies.get(protocol)
+
+          if (topologies == null) {
+            // no topologies are interested in this protocol
+            continue
+          }
+
+          for (const topology of topologies.values()) {
             topology.onDisconnect(connection.remotePeer)
           }
         }
@@ -168,14 +169,28 @@ export class DefaultRegistrar implements Registrar {
     const removed = oldProtocols.filter(protocol => !protocols.includes(protocol))
     const added = protocols.filter(protocol => !oldProtocols.includes(protocol))
 
-    for (const { topology, protocols } of this.topologies.values()) {
+    for (const protocol of removed) {
-      if (supportsProtocol(removed, protocols)) {
+      const topologies = this.topologies.get(protocol)
+
+      if (topologies == null) {
+        // no topologies are interested in this protocol
+        continue
+      }
+
+      for (const topology of topologies.values()) {
         topology.onDisconnect(peerId)
       }
     }
 
-    for (const { topology, protocols } of this.topologies.values()) {
+    for (const protocol of added) {
-      if (supportsProtocol(added, protocols)) {
+      const topologies = this.topologies.get(protocol)
+
+      if (topologies == null) {
+        // no topologies are interested in this protocol
+        continue
+      }
+
+      for (const topology of topologies.values()) {
         const connection = this.components.getConnectionManager().getConnections(peerId)[0]
 
         if (connection == null) {

src/transport-manager.ts

@@ -2,13 +2,13 @@ import { logger } from '@libp2p/logger'
 import pSettle from 'p-settle'
 import { codes } from './errors.js'
 import errCode from 'err-code'
-import type { Listener, Transport, TransportManager, TransportManagerEvents } from '@libp2p/interfaces/transport'
+import type { Listener, Transport, TransportManager, TransportManagerEvents } from '@libp2p/interface-transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 import { trackedMap } from '@libp2p/tracked-map'
 
 const log = logger('libp2p:transports')

src/upgrader.ts

@@ -8,13 +8,13 @@ import { codes } from './errors.js'
 import { createConnection } from '@libp2p/connection'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import { peerIdFromString } from '@libp2p/peer-id'
-import type { Connection, ProtocolStream, Stream } from '@libp2p/interfaces/connection'
+import type { MultiaddrConnection, Connection, ProtocolStream, Stream } from '@libp2p/interface-connection'
-import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interfaces/connection-encrypter'
+import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
-import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
+import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
-import type { MultiaddrConnection, Upgrader, UpgraderEvents } from '@libp2p/interfaces/transport'
+import type { Upgrader, UpgraderEvents } from '@libp2p/interface-transport'
 import type { Duplex } from 'it-stream-types'
-import type { Components } from '@libp2p/interfaces/components'
+import { Components, isInitializable } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
 
 const log = logger('libp2p:upgrader')
@@ -272,7 +272,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
     if (muxerFactory != null) {
       // Create the muxer
-      muxer = muxerFactory.createStreamMuxer(this.components, {
+      muxer = muxerFactory.createStreamMuxer({
         // Run anytime a remote stream is created
         onIncomingStream: muxedStream => {
           if (connection == null) {
@@ -313,6 +313,10 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         }
       })
 
+      if (isInitializable(muxer)) {
+        muxer.init(this.components)
+      }
+
       newStream = async (protocols: string[], options: AbortOptions = {}): Promise<ProtocolStream> => {
         if (muxer == null) {
           throw errCode(new Error('Stream is not multiplexed'), codes.ERR_MUXER_UNAVAILABLE)
@@ -417,7 +421,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    */
   _onStream (opts: OnStreamOptions): void {
     const { connection, stream, protocol } = opts
-    const handler = this.components.getRegistrar().getHandler(protocol)
+    const { handler } = this.components.getRegistrar().getHandler(protocol)
     handler({ connection, stream, protocol })
   }
 

test/addresses/address-manager.spec.ts

@@ -7,10 +7,10 @@ import { createNode } from '../utils/creators/peer.js'
 import { createFromJSON } from '@libp2p/peer-id-factory'
 import Peers from '../fixtures/peers.js'
 import { stubInterface } from 'ts-sinon'
-import type { TransportManager } from '@libp2p/interfaces/transport'
+import type { TransportManager } from '@libp2p/interface-transport'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Libp2p } from '../../src/index.js'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 
 const listenAddresses = ['/ip4/127.0.0.1/tcp/15006/ws', '/ip4/127.0.0.1/tcp/15008/ws']
 const announceAddreses = ['/dns4/peer.io']

test/configuration/pubsub.spec.ts

@@ -9,7 +9,7 @@ import { baseOptions, pubsubSubsystemOptions } from './utils.js'
 import { createPeerId } from '../utils/creators/peer.js'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { FloodSub } from '@libp2p/floodsub'
-import type { PubSub } from '@libp2p/interfaces/pubsub'
+import type { PubSub } from '@libp2p/interface-pubsub'
 
 describe('Pubsub subsystem is configurable', () => {
   let libp2p: Libp2p

test/configuration/utils.ts

@@ -5,9 +5,9 @@ import { WebSockets } from '@libp2p/websockets'
 import * as filters from '@libp2p/websockets/filters'
 import { MULTIADDRS_WEBSOCKETS } from '../fixtures/browser.js'
 import mergeOptions from 'merge-options'
-import type { Message, PublishResult, PubSubInit, PubSubRPC, PubSubRPCMessage } from '@libp2p/interfaces/pubsub'
+import type { Message, PublishResult, PubSubInit, PubSubRPC, PubSubRPCMessage } from '@libp2p/interface-pubsub'
 import type { Libp2pInit, Libp2pOptions } from '../../src/index.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import * as cborg from 'cborg'
 import { peerIdFromString } from '@libp2p/peer-id'
 

test/connection-manager/auto-dialler.spec.ts

@@ -5,10 +5,10 @@ import { AutoDialler } from '../../src/connection-manager/auto-dialler.js'
 import pWaitFor from 'p-wait-for'
 import delay from 'delay'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { stubInterface } from 'ts-sinon'
-import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerStore, Peer } from '@libp2p/interfaces/peer-store'
+import type { PeerStore, Peer } from '@libp2p/interface-peer-store'
 
 describe('Auto-dialler', () => {
   it('should not dial self', async () => {

test/connection-manager/index.node.ts

@@ -2,19 +2,19 @@
 
 import { expect } from 'aegir/chai'
 import { createNode, createPeerId } from '../utils/creators/peer.js'
-import { mockConnection, mockDuplex, mockMultiaddrConnection, mockUpgrader } from '@libp2p/interface-compliance-tests/mocks'
+import { mockConnection, mockDuplex, mockMultiaddrConnection, mockUpgrader } from '@libp2p/interface-mocks'
 import { createBaseOptions } from '../utils/base-options.browser.js'
 import type { Libp2p } from '../../src/index.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { DefaultConnectionManager } from '../../src/connection-manager/index.js'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { CustomEvent } from '@libp2p/interfaces/events'
-import * as STATUS from '@libp2p/interfaces/connection/status'
+import * as STATUS from '@libp2p/interface-connection/status'
 import { stubInterface } from 'ts-sinon'
-import type { KeyBook, PeerStore } from '@libp2p/interfaces/peer-store'
+import type { KeyBook, PeerStore } from '@libp2p/interface-peer-store'
 import sinon from 'sinon'
 import pWaitFor from 'p-wait-for'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
 import delay from 'delay'
 import type { Libp2pNode } from '../../src/libp2p.js'
 import { codes } from '../../src/errors.js'

test/connection-manager/index.spec.ts

@@ -6,7 +6,7 @@ import { createNode } from '../utils/creators/peer.js'
 import { createBaseOptions } from '../utils/base-options.browser.js'
 import type { Libp2pNode } from '../../src/libp2p.js'
 import type { DefaultConnectionManager } from '../../src/connection-manager/index.js'
-import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-compliance-tests/mocks'
+import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-mocks'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { CustomEvent } from '@libp2p/interfaces/events'
 

test/content-routing/content-routing.node.ts

@@ -14,7 +14,7 @@ import { createNode, createPeerId, populateAddressBooks } from '../utils/creator
 import { createBaseOptions } from '../utils/base-options.js'
 import { createRoutingOptions } from './utils.js'
 import type { Libp2p } from '../../src/index.js'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { Libp2pNode } from '../../src/libp2p.js'
 
 describe('content-routing', () => {

test/content-routing/dht/operation.node.ts

@@ -6,7 +6,7 @@ import pWaitFor from 'p-wait-for'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { subsystemMulticodecs, createSubsystemOptions } from './utils.js'
 import { createPeerId } from '../../utils/creators/peer.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { createLibp2pNode, Libp2pNode } from '../../../src/libp2p.js'
 import { start } from '@libp2p/interfaces/startable'
 

test/core/encryption.spec.ts

@@ -6,7 +6,7 @@ import { NOISE } from '@chainsafe/libp2p-noise'
 import { createLibp2p, Libp2pOptions } from '../../src/index.js'
 import { codes as ErrorCodes } from '../../src/errors.js'
 import { createPeerId } from '../utils/creators/peer.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 
 describe('Connection encryption configuration', () => {
   let peerId: PeerId

test/core/listening.node.ts

@@ -4,7 +4,7 @@ import { expect } from 'aegir/chai'
 import { TCP } from '@libp2p/tcp'
 import { NOISE } from '@chainsafe/libp2p-noise'
 import { createPeerId } from '../utils/creators/peer.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
 
 const listenAddr = '/ip4/0.0.0.0/tcp/0'

test/dialing/dial-request.spec.ts

@@ -6,7 +6,7 @@ import { AbortError } from '@libp2p/interfaces/errors'
 import pDefer from 'p-defer'
 import delay from 'delay'
 import { DialAction, DialRequest } from '../../src/connection-manager/dialer/dial-request.js'
-import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-compliance-tests/mocks'
+import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-mocks'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { Multiaddr } from '@multiformats/multiaddr'
 import { Dialer } from '../../src/connection-manager/dialer/index.js'

test/dialing/direct.node.ts

@@ -13,7 +13,7 @@ import pSettle, { PromiseResult } from 'p-settle'
 import pWaitFor from 'p-wait-for'
 import { pipe } from 'it-pipe'
 import { pushable } from 'it-pushable'
-import { Connection, isConnection } from '@libp2p/interfaces/connection'
+import { Connection, isConnection } from '@libp2p/interface-connection'
 import { AbortError } from '@libp2p/interfaces/errors'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { MemoryDatastore } from 'datastore-core/memory'
@@ -22,11 +22,11 @@ import { DefaultAddressManager } from '../../src/address-manager/index.js'
 import { PersistentPeerStore } from '@libp2p/peer-store'
 import { DefaultTransportManager } from '../../src/transport-manager.js'
 import { codes as ErrorCodes } from '../../src/errors.js'
-import { mockConnectionGater, mockDuplex, mockMultiaddrConnection, mockUpgrader, mockConnection } from '@libp2p/interface-compliance-tests/mocks'
+import { mockConnectionGater, mockDuplex, mockMultiaddrConnection, mockUpgrader, mockConnection } from '@libp2p/interface-mocks'
 import Peers from '../fixtures/peers.js'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { createFromJSON } from '@libp2p/peer-id-factory'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
 import { PreSharedKeyConnectionProtector } from '../../src/pnet/index.js'
 import swarmKey from '../fixtures/swarm.key.js'
@@ -382,7 +382,7 @@ describe('libp2p.dialer (direct, TCP)', () => {
     await libp2p.dialProtocol(remoteLibp2p.peerId, '/stream-count/4')
 
     // Partially write to the echo stream
-    const source = pushable<Uint8Array>()
+    const source = pushable()
     void stream.sink(source)
     source.push(uint8ArrayFromString('hello'))
 

test/dialing/direct.spec.ts

@@ -17,18 +17,18 @@ import { Dialer, DialTarget } from '../../src/connection-manager/dialer/index.js
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { PersistentPeerStore } from '@libp2p/peer-store'
 import { DefaultTransportManager } from '../../src/transport-manager.js'
-import { mockConnectionGater, mockDuplex, mockMultiaddrConnection, mockUpgrader, mockConnection } from '@libp2p/interface-compliance-tests/mocks'
+import { mockConnectionGater, mockDuplex, mockMultiaddrConnection, mockUpgrader, mockConnection } from '@libp2p/interface-mocks'
 import { createPeerId } from '../utils/creators/peer.js'
-import type { TransportManager } from '@libp2p/interfaces/transport'
+import type { TransportManager } from '@libp2p/interface-transport'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { peerIdFromString } from '@libp2p/peer-id'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
 import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
 import { DefaultConnectionManager } from '../../src/connection-manager/index.js'
 import { createFromJSON } from '@libp2p/peer-id-factory'
 import Peers from '../fixtures/peers.js'
 import { MULTIADDRS_WEBSOCKETS } from '../fixtures/browser.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { pEvent } from 'p-event'
 
 const unsupportedAddr = new Multiaddr('/ip4/127.0.0.1/tcp/9999')

test/dialing/resolver.spec.ts

@@ -7,11 +7,11 @@ import { codes as ErrorCodes } from '../../src/errors.js'
 import { createNode } from '../utils/creators/peer.js'
 import { createBaseOptions } from '../utils/base-options.browser.js'
 import { MULTIADDRS_WEBSOCKETS } from '../fixtures/browser.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Libp2pNode } from '../../src/libp2p.js'
 import { Circuit } from '../../src/circuit/transport.js'
 import pDefer from 'p-defer'
-import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-compliance-tests/mocks'
+import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-mocks'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { WebSockets } from '@libp2p/websockets'
 

test/fetch/fetch.node.ts

@@ -7,7 +7,7 @@ import { Mplex } from '@libp2p/mplex'
 import { NOISE } from '@chainsafe/libp2p-noise'
 import { createPeerId } from '../utils/creators/peer.js'
 import { codes } from '../../src/errors.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 
 async function createNode (peerId: PeerId) {
   return await createLibp2pNode({

test/fetch/index.spec.ts

@@ -4,9 +4,9 @@ import { expect } from 'aegir/chai'
 import sinon from 'sinon'
 import { FetchService } from '../../src/fetch/index.js'
 import Peers from '../fixtures/peers.js'
-import { mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-compliance-tests/mocks'
+import { mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-mocks'
 import { createFromJSON } from '@libp2p/peer-id-factory'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { DefaultConnectionManager } from '../../src/connection-manager/index.js'
 import { start, stop } from '@libp2p/interfaces/startable'
 import { CustomEvent } from '@libp2p/interfaces/events'

test/identify/index.spec.ts

@@ -14,9 +14,9 @@ import { MemoryDatastore } from 'datastore-core/memory'
 import * as lp from 'it-length-prefixed'
 import drain from 'it-drain'
 import { pipe } from 'it-pipe'
-import { mockConnectionGater, mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-compliance-tests/mocks'
+import { mockConnectionGater, mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-mocks'
 import { createFromJSON } from '@libp2p/peer-id-factory'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { PeerRecordUpdater } from '../../src/peer-record-updater.js'
 import {
   MULTICODEC_IDENTIFY,

test/identify/push.spec.ts

@@ -10,9 +10,9 @@ import { DefaultAddressManager } from '../../src/address-manager/index.js'
 import { MemoryDatastore } from 'datastore-core/memory'
 import drain from 'it-drain'
 import { pipe } from 'it-pipe'
-import { mockConnectionGater, mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-compliance-tests/mocks'
+import { mockConnectionGater, mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-mocks'
 import { createFromJSON } from '@libp2p/peer-id-factory'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { PeerRecordUpdater } from '../../src/peer-record-updater.js'
 import {
   MULTICODEC_IDENTIFY,

test/identify/service.spec.ts

@@ -11,7 +11,7 @@ import { MULTIADDRS_WEBSOCKETS } from '../fixtures/browser.js'
 import { createFromJSON } from '@libp2p/peer-id-factory'
 import pWaitFor from 'p-wait-for'
 import { peerIdFromString } from '@libp2p/peer-id'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Libp2pNode } from '../../src/libp2p.js'
 import { pEvent } from 'p-event'
 

test/insecure/compliance.spec.ts

@@ -1,6 +1,6 @@
 /* eslint-env mocha */
 
-import suite from '@libp2p/interface-compliance-tests/connection-encrypter'
+import suite from '@libp2p/interface-connection-encrypter-compliance-tests'
 import { Plaintext } from '../../src/insecure/index.js'
 
 describe('plaintext compliance', () => {

test/insecure/plaintext.spec.ts

@@ -7,11 +7,11 @@ import { Plaintext } from '../../src/insecure/index.js'
 import {
   InvalidCryptoExchangeError,
   UnexpectedPeerError
-} from '@libp2p/interfaces/connection-encrypter/errors'
+} from '@libp2p/interface-connection-encrypter/errors'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { createFromJSON, createRSAPeerId } from '@libp2p/peer-id-factory'
-import type { ConnectionEncrypter } from '@libp2p/interfaces/connection-encrypter'
+import type { ConnectionEncrypter } from '@libp2p/interface-connection-encrypter'
-import { mockMultiaddrConnPair } from '@libp2p/interface-compliance-tests/mocks'
+import { mockMultiaddrConnPair } from '@libp2p/interface-mocks'
 import { Multiaddr } from '@multiformats/multiaddr'
 import { peerIdFromBytes } from '@libp2p/peer-id'
 

test/interop.ts

@@ -14,7 +14,7 @@ import { logger } from '@libp2p/logger'
 import { Mplex } from '@libp2p/mplex'
 import fs from 'fs'
 import { unmarshalPrivateKey } from '@libp2p/crypto/keys'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { peerIdFromKeys } from '@libp2p/peer-id'
 import { FloodSub } from '@libp2p/floodsub'
 

test/keychain/cms-interop.spec.ts

@@ -6,7 +6,7 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { MemoryDatastore } from 'datastore-core/memory'
 import { KeyChain } from '../../src/keychain/index.js'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 
 describe('cms interop', () => {
   const passPhrase = 'this is not a secure phrase'

test/keychain/keychain.spec.ts

@@ -9,9 +9,9 @@ import { Key } from 'interface-datastore/key'
 import { MemoryDatastore } from 'datastore-core/memory'
 import { KeyChain, KeyChainInit, KeyInfo } from '../../src/keychain/index.js'
 import { pbkdf2 } from '@libp2p/crypto'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import type { Datastore } from 'interface-datastore'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { createFromPrivKey } from '@libp2p/peer-id-factory'
 import { unmarshalPrivateKey } from '@libp2p/crypto/keys'
 

test/keychain/peerid.spec.ts

@@ -4,7 +4,7 @@ import { expect } from 'aegir/chai'
 import { base58btc } from 'multiformats/bases/base58'
 import { supportedKeys, unmarshalPrivateKey, unmarshalPublicKey } from '@libp2p/crypto/keys'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { createFromPrivKey } from '@libp2p/peer-id-factory'
 
 const sample = {

test/metrics/index.spec.ts

@@ -14,7 +14,7 @@ import { createPeerId } from '../utils/creators/peer.js'
 import toBuffer from 'it-to-buffer'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { peerIdFromString } from '@libp2p/peer-id'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 
 describe('Metrics', () => {
   let peerId: PeerId
@@ -199,7 +199,7 @@ describe('Metrics', () => {
     })
 
     const bytes = randomBytes(1024)
-    const input = pushable<Uint8Array>()
+    const input = pushable()
 
     const deferredPromise = pipe(input, local, drain)
 

test/nat-manager/nat-manager.node.ts

@@ -4,13 +4,13 @@ import { expect } from 'aegir/chai'
 import { DefaultAddressManager } from '../../src/address-manager/index.js'
 import { DefaultTransportManager, FaultTolerance } from '../../src/transport-manager.js'
 import { TCP } from '@libp2p/tcp'
-import { mockUpgrader } from '@libp2p/interface-compliance-tests/mocks'
+import { mockUpgrader } from '@libp2p/interface-mocks'
 import { NatManager } from '../../src/nat-manager.js'
 import delay from 'delay'
 import Peers from '../fixtures/peers.js'
 import { codes } from '../../src/errors.js'
 import { createFromJSON } from '@libp2p/peer-id-factory'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import type { NatAPI } from '@achingbrain/nat-port-mapper'
 import { StubbedInstance, stubInterface } from 'ts-sinon'
 import { start, stop } from '@libp2p/interfaces/startable'

test/peer-discovery/index.node.ts

@@ -11,10 +11,10 @@ import { Multiaddr } from '@multiformats/multiaddr'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { createBaseOptions } from '../utils/base-options.js'
 import { createPeerId } from '../utils/creators/peer.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
 import { CustomEvent } from '@libp2p/interfaces/events'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 
 const listenAddr = new Multiaddr('/ip4/127.0.0.1/tcp/0')
 

test/peer-discovery/index.spec.ts

@@ -6,9 +6,9 @@ import defer from 'p-defer'
 import { Multiaddr } from '@multiformats/multiaddr'
 import { createBaseOptions } from '../utils/base-options.browser.js'
 import { createPeerId } from '../utils/creators/peer.js'
-import { isPeerId, PeerId } from '@libp2p/interfaces/peer-id'
+import { isPeerId, PeerId } from '@libp2p/interface-peer-id'
 import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
-import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-compliance-tests/mocks'
+import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-mocks'
 import type { Startable } from '@libp2p/interfaces/startable'
 
 describe('peer discovery', () => {

test/peer-routing/peer-routing.node.ts

@@ -16,11 +16,11 @@ import { createNode, createPeerId, populateAddressBooks } from '../utils/creator
 import type { Libp2pNode } from '../../src/libp2p.js'
 import { createBaseOptions } from '../utils/base-options.js'
 import { createRoutingOptions } from './utils.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
-import { EventTypes, MessageType } from '@libp2p/interfaces/dht'
+import { EventTypes, MessageType } from '@libp2p/interface-dht'
 import { peerIdFromString } from '@libp2p/peer-id'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 import { KadDHT } from '@libp2p/kad-dht'
 
 describe('peer-routing', () => {

test/ping/index.spec.ts

@@ -4,9 +4,9 @@ import { expect } from 'aegir/chai'
 import sinon from 'sinon'
 import { PingService } from '../../src/ping/index.js'
 import Peers from '../fixtures/peers.js'
-import { mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-compliance-tests/mocks'
+import { mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-mocks'
 import { createFromJSON } from '@libp2p/peer-id-factory'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { DefaultConnectionManager } from '../../src/connection-manager/index.js'
 import { start, stop } from '@libp2p/interfaces/startable'
 import { CustomEvent } from '@libp2p/interfaces/events'

test/pnet/index.spec.ts

@@ -5,7 +5,7 @@ import all from 'it-all'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { PreSharedKeyConnectionProtector, generateKey } from '../../src/pnet/index.js'
 import { INVALID_PSK } from '../../src/pnet/errors.js'
-import { mockMultiaddrConnPair } from '@libp2p/interface-compliance-tests/mocks'
+import { mockMultiaddrConnPair } from '@libp2p/interface-mocks'
 import { Multiaddr } from '@multiformats/multiaddr'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 

test/registrar/registrar.spec.ts

@@ -6,21 +6,21 @@ import { MemoryDatastore } from 'datastore-core/memory'
 import { createTopology } from '@libp2p/topology'
 import { PersistentPeerStore } from '@libp2p/peer-store'
 import { DefaultRegistrar } from '../../src/registrar.js'
-import { mockDuplex, mockMultiaddrConnection, mockUpgrader, mockConnection } from '@libp2p/interface-compliance-tests/mocks'
+import { mockDuplex, mockMultiaddrConnection, mockUpgrader, mockConnection } from '@libp2p/interface-mocks'
 import { createPeerId, createNode } from '../utils/creators/peer.js'
 import { createBaseOptions } from '../utils/base-options.browser.js'
-import type { Registrar } from '@libp2p/interfaces/registrar'
+import type { Registrar } from '@libp2p/interface-registrar'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { CustomEvent } from '@libp2p/interfaces/events'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
 import { DefaultConnectionManager } from '../../src/connection-manager/index.js'
 import { Plaintext } from '../../src/insecure/index.js'
 import { WebSockets } from '@libp2p/websockets'
 import { Mplex } from '@libp2p/mplex'
-import type { PeerProtocolsChangeData } from '@libp2p/interfaces/peer-store'
+import type { PeerProtocolsChangeData } from '@libp2p/interface-peer-store'
 
 const protocol = '/test/1.0.0'
 
@@ -238,12 +238,12 @@ describe('registrar', () => {
 
       const echoHandler = () => {}
       await libp2p.handle(['/echo/1.0.0', '/echo/1.0.1'], echoHandler)
-      expect(registrar.getHandler('/echo/1.0.0')).to.equal(echoHandler)
+      expect(registrar.getHandler('/echo/1.0.0')).to.have.property('handler', echoHandler)
-      expect(registrar.getHandler('/echo/1.0.1')).to.equal(echoHandler)
+      expect(registrar.getHandler('/echo/1.0.1')).to.have.property('handler', echoHandler)
 
       await libp2p.unhandle(['/echo/1.0.0'])
       expect(registrar.getProtocols()).to.not.have.any.keys(['/echo/1.0.0'])
-      expect(registrar.getHandler('/echo/1.0.1')).to.equal(echoHandler)
+      expect(registrar.getHandler('/echo/1.0.1')).to.have.property('handler', echoHandler)
     })
   })
 })

test/transports/transport-manager.node.ts

@@ -8,13 +8,13 @@ import { PersistentPeerStore } from '@libp2p/peer-store'
 import { PeerRecord } from '@libp2p/peer-record'
 import { TCP } from '@libp2p/tcp'
 import { Multiaddr } from '@multiformats/multiaddr'
-import { mockUpgrader } from '@libp2p/interface-compliance-tests/mocks'
+import { mockUpgrader } from '@libp2p/interface-mocks'
 import sinon from 'sinon'
 import Peers from '../fixtures/peers.js'
 import pWaitFor from 'p-wait-for'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { createFromJSON } from '@libp2p/peer-id-factory'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { PeerRecordUpdater } from '../../src/peer-record-updater.js'
 
 const addrs = [

test/transports/transport-manager.spec.ts

@@ -8,13 +8,13 @@ import * as filters from '@libp2p/websockets/filters'
 import { NOISE } from '@chainsafe/libp2p-noise'
 import { DefaultAddressManager } from '../../src/address-manager/index.js'
 import { DefaultTransportManager, FaultTolerance } from '../../src/transport-manager.js'
-import { mockUpgrader } from '@libp2p/interface-compliance-tests/mocks'
+import { mockUpgrader } from '@libp2p/interface-mocks'
 import { MULTIADDRS_WEBSOCKETS } from '../fixtures/browser.js'
 import { codes as ErrorCodes } from '../../src/errors.js'
 import Peers from '../fixtures/peers.js'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { createEd25519PeerId, createFromJSON } from '@libp2p/peer-id-factory'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
 
 const listenAddr = new Multiaddr('/ip4/127.0.0.1/tcp/0')

test/upgrading/upgrader.spec.ts

@@ -14,16 +14,16 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import swarmKey from '../fixtures/swarm.key.js'
 import { DefaultUpgrader } from '../../src/upgrader.js'
 import { codes } from '../../src/errors.js'
-import { mockConnectionGater, mockMultiaddrConnPair, mockRegistrar, mockStream } from '@libp2p/interface-compliance-tests/mocks'
+import { mockConnectionGater, mockMultiaddrConnPair, mockRegistrar, mockStream } from '@libp2p/interface-mocks'
 import Peers from '../fixtures/peers.js'
-import type { Upgrader } from '@libp2p/interfaces/transport'
+import type { Upgrader } from '@libp2p/interface-transport'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { createFromJSON } from '@libp2p/peer-id-factory'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { Plaintext } from '../../src/insecure/index.js'
-import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interfaces/connection-encrypter'
+import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
-import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interfaces/stream-muxer'
+import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface-stream-muxer'
-import type { Stream } from '@libp2p/interfaces/connection'
+import type { Stream } from '@libp2p/interface-connection'
 import pDefer from 'p-defer'
 import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
 import { pEvent } from 'p-event'
@@ -248,7 +248,7 @@ describe('Upgrader', () => {
     class OtherMuxerFactory implements StreamMuxerFactory {
       protocol = '/muxer-local'
 
-      createStreamMuxer (components: Components, init?: StreamMuxerInit): StreamMuxer {
+      createStreamMuxer (init?: StreamMuxerInit): StreamMuxer {
         return new OtherMuxer()
       }
     }

test/utils/creators/peer.ts

@@ -4,7 +4,7 @@ import { createBaseOptions } from '../base-options.browser.js'
 import { createEd25519PeerId, createFromJSON, createRSAPeerId } from '@libp2p/peer-id-factory'
 import { createLibp2pNode, Libp2pNode } from '../../../src/libp2p.js'
 import type { AddressesConfig, Libp2pOptions } from '../../../src/index.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 
 const listenAddr = new Multiaddr('/ip4/127.0.0.1/tcp/0')