libp2p 0.37.3 → 0.38.0

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,33 +6,47 @@ 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'
+import { TimeoutController } from 'timeout-abort-controller'
+import type { Stream } from '@libp2p/interface-connection'
+import { setMaxListeners } from 'events'
 
 const log = logger('libp2p:ping')
 
 export interface PingServiceInit {
   protocolPrefix: string
+  maxInboundStreams: number
+  maxOutboundStreams: number
+
+  /**
+   * How long we should wait for a ping response
+   */
+  timeout: 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
   }
 
@@ -66,19 +80,32 @@ export class PingService implements Startable {
   async ping (peer: PeerId, options: AbortOptions = {}): Promise<number> {
     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 start = Date.now()
     const data = randomBytes(PING_LENGTH)
-
-    let source: Duplex<Uint8Array> = stream
-
-    // make stream abortable if AbortSignal passed
-    if (options.signal != null) {
-      source = abortableDuplex(stream, options.signal)
+    const connection = await this.components.getConnectionManager().openConnection(peer, options)
+    let timeoutController
+    let signal = options.signal
+    let stream: Stream | undefined
+
+    // create a timeout if no abort signal passed
+    if (signal == null) {
+      timeoutController = new TimeoutController(this.init.timeout)
+      signal = timeoutController.signal
+
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, timeoutController.signal)
+      } catch {}
     }
 
     try {
+      stream = await connection.newStream([this.protocol], {
+        signal
+      })
+
+      // make stream abortable
+      const source = abortableDuplex(stream, signal)
+
       const result = await pipe(
         [data],
         source,
@@ -86,13 +113,19 @@ export class PingService implements Startable {
       )
       const end = Date.now()
 
-      if (result == null || !uint8ArrayEquals(data, result)) {
+      if (result == null || !uint8ArrayEquals(data, result.subarray())) {
         throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
       }
 
       return end - start
     } finally {
-      stream.close()
+      if (timeoutController != null) {
+        timeoutController.clear()
+      }
+
+      if (stream != null) {
+        stream.close()
+      }
     }
   }
 }

package/src/pnet/index.ts

@@ -12,8 +12,8 @@ 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'
+import map from 'it-map'
 
 const log = logger('libp2p:pnet')
 
@@ -84,6 +84,7 @@ export class PreSharedKeyConnectionProtector implements ConnectionProtector {
       // Encrypt all outbound traffic
       createBoxStream(localNonce, this.psk),
       shake.stream,
+      (source) => map(source, (buf) => buf.subarray()),
       // Decrypt all inbound traffic
       createUnboxStream(remoteNonce, this.psk),
       external

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 = 32
+export const DEFAULT_MAX_OUTBOUND_STREAMS = 64
 
 /**
  * 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) {

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