libp2p 0.37.2 → 0.37.3-2836acc

package/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 { Connection, Stream } from '@libp2p/interfaces/connection'
+import type { IncomingStreamData } from '@libp2p/interface-registrar'
+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'
@@ -60,6 +60,12 @@ export interface IdentifyServiceInit {
    * Identify responses larger than this in bytes will be rejected (default: 8192)
    */
   maxIdentifyMessageSize?: number
+
+  maxInboundStreams: number
+  maxOutboundStreams: number
+
+  maxPushIncomingStreams: number
+  maxPushOutgoingStreams: number
 }
 
 export class IdentifyService implements Startable {
@@ -79,8 +85,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,13 +131,21 @@ 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([
-      this.identifyProtocolStr,
-      this.identifyPushProtocolStr
-    ], (data) => {
-      void this.handleMessage(data)?.catch(err => {
+    await this.components.getRegistrar().handle(this.identifyProtocolStr, (data) => {
+      void this._handleIdentify(data).catch(err => {
+        log.error(err)
+      })
+    }, {
+      maxInboundStreams: this.init.maxInboundStreams,
+      maxOutboundStreams: this.init.maxOutboundStreams
+    })
+    await this.components.getRegistrar().handle(this.identifyPushProtocolStr, (data) => {
+      void this._handlePush(data).catch(err => {
         log.error(err)
       })
+    }, {
+      maxInboundStreams: this.init.maxPushIncomingStreams,
+      maxOutboundStreams: this.init.maxPushOutgoingStreams
     })
 
     this.started = true
@@ -159,10 +171,9 @@ export class IdentifyService implements Startable {
       let stream: Stream | undefined
 
       try {
-        const data = await connection.newStream([this.identifyPushProtocolStr], {
+        stream = await connection.newStream([this.identifyPushProtocolStr], {
           signal: timeoutController.signal
         })
-        stream = data.stream
 
         // make stream abortable
         const source: Duplex<Uint8Array> = abortableDuplex(stream, timeoutController.signal)
@@ -218,7 +229,7 @@ export class IdentifyService implements Startable {
   }
 
   async _identify (connection: Connection, options: AbortOptions = {}): Promise<Identify> {
-    const { stream } = await connection.newStream([this.identifyProtocolStr], options)
+    const stream = await connection.newStream([this.identifyProtocolStr], options)
     let source: Duplex<Uint8Array> = stream
     let timeoutController
     let signal = options.signal
@@ -353,22 +364,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`

package/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 { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerStore, PeerStoreInit } from '@libp2p/interface-peer-store'
+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 { Connection, ConnectionGater, ConnectionProtector, ProtocolStream } from '@libp2p/interfaces/connection'
-import type { Transport } from '@libp2p/interfaces/transport'
-import type { StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
-import type { ConnectionEncrypter } from '@libp2p/interfaces/connection-encrypter'
-import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
-import type { ContentRouting } from '@libp2p/interfaces/content-routing'
-import type { PubSub } from '@libp2p/interfaces/pubsub'
-import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
-import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
-import type { Metrics, MetricsInit } from '@libp2p/interfaces/metrics'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { PeerDiscovery } from '@libp2p/interface-peer-discovery'
+import type { Connection, ConnectionGater, ConnectionProtector, Stream } from '@libp2p/interface-connection'
+import type { Transport } from '@libp2p/interface-transport'
+import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
+import type { ConnectionEncrypter } from '@libp2p/interface-connection-encrypter'
+import type { PeerRouting } from '@libp2p/interface-peer-routing'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
+import type { PubSub } from '@libp2p/interface-pubsub'
+import type { Registrar, StreamHandler, StreamHandlerOptions } from '@libp2p/interface-registrar'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { Metrics, MetricsInit } from '@libp2p/interface-metrics'
+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'
@@ -177,7 +177,7 @@ export interface Libp2p extends Startable, EventEmitter<Libp2pEvents> {
    * If successful, the known metadata of the peer will be added to the nodes `peerStore`,
    * and the `MuxedStream` will be returned together with the successful negotiated protocol.
    */
-  dialProtocol: (peer: PeerId | Multiaddr, protocols: string | string[], options?: AbortOptions) => Promise<ProtocolStream>
+  dialProtocol: (peer: PeerId | Multiaddr, protocols: string | string[], options?: AbortOptions) => Promise<Stream>
 
   /**
    * Disconnects all connections to the given `peer`
@@ -187,7 +187,7 @@ export interface Libp2p extends Startable, EventEmitter<Libp2pEvents> {
   /**
    * Registers the `handler` for each protocol
    */
-  handle: (protocol: string | string[], handler: StreamHandler) => Promise<void>
+  handle: (protocol: string | string[], handler: StreamHandler, options?: StreamHandlerOptions) => Promise<void>
 
   /**
    * Removes the handler for each protocol. The protocol

package/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')

package/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 { Components } from '@libp2p/interfaces/components'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { Components } from '@libp2p/components'
 import { pbkdf2, randomBytes } from '@libp2p/crypto'
 
 const log = logger('libp2p:keychain')

package/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 type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { Connection } from '@libp2p/interfaces/connection'
-import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
-import type { ContentRouting } from '@libp2p/interfaces/content-routing'
-import type { PubSub } from '@libp2p/interfaces/pubsub'
-import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
-import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import { Initializable, Components, isInitializable } from '@libp2p/components'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { Connection } from '@libp2p/interface-connection'
+import type { PeerRouting } from '@libp2p/interface-peer-routing'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
+import type { PubSub } from '@libp2p/interface-pubsub'
+import type { Registrar, StreamHandler, StreamHandlerOptions } from '@libp2p/interface-registrar'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+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 { DualDHT } from '@libp2p/interfaces/dht'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+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'
@@ -309,18 +309,6 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
       )
 
       log('libp2p has started')
-
-      // Once we start, emit any peers we may have already discovered
-      // TODO: this should be removed, as we already discovered these peers in the past
-      await this.components.getPeerStore().forEach(peer => {
-        this.dispatchEvent(new CustomEvent<PeerInfo>('peer:discovery', {
-          detail: {
-            id: peer.id,
-            multiaddrs: peer.addresses.map(addr => addr.multiaddr),
-            protocols: peer.protocols
-          }
-        }))
-      })
     } catch (err: any) {
       log.error('An error occurred starting libp2p', err)
       await this.stop()
@@ -490,12 +478,28 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     return await this.pingService.ping(id, options)
   }
 
-  async handle (protocols: string | string[], handler: StreamHandler): Promise<void> {
-    return await this.components.getRegistrar().handle(protocols, handler)
+  async handle (protocols: string | string[], handler: StreamHandler, options?: StreamHandlerOptions): Promise<void> {
+    if (!Array.isArray(protocols)) {
+      protocols = [protocols]
+    }
+
+    await Promise.all(
+      protocols.map(async protocol => {
+        await this.components.getRegistrar().handle(protocol, handler, options)
+      })
+    )
   }
 
   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)
+      })
+    )
   }
 
   /**

package/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 { PeerId } from '@libp2p/interfaces/peer-id'
+import type { ComponentMetricsUpdate, Metrics, Stats, TrackStreamOptions } from '@libp2p/interface-metrics'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { Duplex } from 'it-stream-types'
 

package/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

package/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>

package/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

package/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'

package/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 { PeerRouting } from '@libp2p/interfaces/peer-routing'
+import type { PeerId } from '@libp2p/interface-peer-id'
+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 { Components } from '@libp2p/interfaces/components'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { Components } from '@libp2p/components'
 
 const log = logger('libp2p:peer-routing')
 

package/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 { PeerId } from '@libp2p/interfaces/peer-id'
+import type { IncomingStreamData } from '@libp2p/interface-registrar'
+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'
@@ -18,21 +18,28 @@ const log = logger('libp2p:ping')
 
 export interface PingServiceInit {
   protocolPrefix: string
+  maxInboundStreams: number
+  maxOutboundStreams: number
 }
 
 export class PingService implements Startable {
   public readonly protocol: string
   private readonly components: Components
   private started: boolean
+  private readonly init: PingServiceInit
 
   constructor (components: Components, init: PingServiceInit) {
     this.components = components
     this.started = false
     this.protocol = `/${init.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
+    this.init = init
   }
 
   async start () {
-    await this.components.getRegistrar().handle(this.protocol, this.handleMessage)
+    await this.components.getRegistrar().handle(this.protocol, this.handleMessage, {
+      maxInboundStreams: this.init.maxInboundStreams,
+      maxOutboundStreams: this.init.maxOutboundStreams
+    })
     this.started = true
   }
 
@@ -67,7 +74,7 @@ export class PingService implements Startable {
     log('dialing %s to %p', this.protocol, peer)
 
     const connection = await this.components.getConnectionManager().openConnection(peer, options)
-    const { stream } = await connection.newStream([this.protocol], options)
+    const stream = await connection.newStream([this.protocol], options)
     const start = Date.now()
     const data = randomBytes(PING_LENGTH)
 

package/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 } from '@libp2p/interfaces/connection'
+import type { ConnectionProtector, MultiaddrConnection } from '@libp2p/interface-connection'
 
 const log = logger('libp2p:pnet')
 

package/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 { PublishResult, PubSub, PubSubEvents, StrictNoSign, StrictSign } from '@libp2p/interfaces/pubsub'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PublishResult, PubSub, PubSubEvents, StrictNoSign, StrictSign } from '@libp2p/interface-pubsub'
 import errCode from 'err-code'
 import { messages, codes } from '../errors.js'
 

package/src/registrar.ts

@@ -1,30 +1,24 @@
 import { logger } from '@libp2p/logger'
 import errCode from 'err-code'
 import { codes } from './errors.js'
-import { isTopology, Topology } from '@libp2p/interfaces/topology'
-import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
-import type { PeerProtocolsChangeData } from '@libp2p/interfaces/peer-store'
-import type { Connection } from '@libp2p/interfaces/connection'
-import type { Components } from '@libp2p/interfaces/components'
+import { isTopology, StreamHandlerOptions, StreamHandlerRecord } from '@libp2p/interface-registrar'
+import merge from 'merge-options'
+import type { Registrar, StreamHandler, Topology } from '@libp2p/interface-registrar'
+import type { PeerProtocolsChangeData } from '@libp2p/interface-peer-store'
+import type { Connection } from '@libp2p/interface-connection'
+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
-}
+export const DEFAULT_MAX_INBOUND_STREAMS = 1
+export const DEFAULT_MAX_OUTBOUND_STREAMS = 1
 
 /**
  * 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 handlers: Map<string, StreamHandler>
+  private readonly topologies: Map<string, Map<string, Topology>>
+  private readonly handlers: Map<string, StreamHandlerRecord>
   private readonly components: Components
 
   constructor (components: Components) {
@@ -42,57 +36,54 @@ export class DefaultRegistrar implements Registrar {
   }
 
   getProtocols () {
-    const protocols = new Set<string>()
-
-    for (const topology of this.topologies.values()) {
-      topology.protocols.forEach(protocol => protocols.add(protocol))
-    }
-
-    for (const protocol of this.handlers.keys()) {
-      protocols.add(protocol)
-    }
-
-    return Array.from(protocols).sort()
+    return Array.from(new Set<string>([
+      ...this.topologies.keys(),
+      ...this.handlers.keys()
+    ])).sort()
   }
 
   getHandler (protocol: string) {
     const handler = this.handlers.get(protocol)
 
     if (handler == null) {
-      throw new Error(`No handler registered for protocol ${protocol}`)
+      throw errCode(new Error(`No handler registered for protocol ${protocol}`), codes.ERR_NO_HANDLER_FOR_PROTOCOL)
     }
 
     return handler
   }
 
   getTopologies (protocol: string) {
-    const output: Topology[] = []
+    const topologies = this.topologies.get(protocol)
 
-    for (const { topology, protocols } of this.topologies.values()) {
-      if (protocols.includes(protocol)) {
-        output.push(topology)
-      }
+    if (topologies == null) {
+      return []
     }
 
-    return output
+    return [
+      ...topologies.values()
+    ]
   }
 
   /**
    * Registers the `handler` for each protocol
    */
-  async handle (protocols: string | string[], handler: StreamHandler): Promise<void> {
-    const protocolList = Array.isArray(protocols) ? protocols : [protocols]
+  async handle (protocol: string, handler: StreamHandler, opts?: StreamHandlerOptions): Promise<void> {
+    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)
-      }
+    const options = merge.bind({ ignoreUndefined: true })({
+      maxInboundStreams: DEFAULT_MAX_INBOUND_STREAMS,
+      maxOutboundStreams: DEFAULT_MAX_OUTBOUND_STREAMS
+    }, opts)
 
-      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 +104,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 +113,14 @@ export class DefaultRegistrar implements Registrar {
     // Create topology
     const id = `${(Math.random() * 1e9).toString(36)}${Date.now()}`
 
-    this.topologies.set(id, {
-      topology,
-      protocols: Array.isArray(protocols) ? protocols : [protocols]
-    })
+    let topologies = this.topologies.get(protocol)
+
+    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 +132,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 +151,15 @@ export class DefaultRegistrar implements Registrar {
 
     void this.components.getPeerStore().protoBook.get(connection.remotePeer)
       .then(peerProtocols => {
-        for (const { topology, protocols } of this.topologies.values()) {
-          if (supportsProtocol(peerProtocols, protocols)) {
+        for (const protocol of peerProtocols) {
+          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 +178,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()) {
-      if (supportsProtocol(removed, protocols)) {
+    for (const protocol of removed) {
+      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()) {
-      if (supportsProtocol(added, protocols)) {
+    for (const protocol of added) {
+      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) {