libp2p 2.10.0-a02cb0461 → 2.10.0-e8398d97e

package/src/connection-manager/index.ts

@@ -1,6 +1,6 @@
 import { ConnectionClosedError, InvalidMultiaddrError, InvalidParametersError, InvalidPeerIdError, NotStartedError, start, stop } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
-import { RateLimiter } from '@libp2p/utils'
+import { getNetConfig, isNetworkAddress, RateLimiter } from '@libp2p/utils'
 import { multiaddr } from '@multiformats/multiaddr'
 import { pEvent } from 'p-event'
 import { CustomProgressEvent } from 'progress-events'
@@ -82,24 +82,6 @@ export interface ConnectionManagerInit {
    */
   inboundUpgradeTimeout?: number
 
-  /**
-   * When a new outbound connection is opened, the upgrade process (e.g.
-   * protect, encrypt, multiplex etc) must complete within this number of ms.
-   *
-   * Does not apply if an abort signal is passed to the `.dial` method.
-   *
-   * @deprecated This is handled by `dialTimeout`
-   */
-  outboundUpgradeTimeout?: number
-
-  /**
-   * Protocol negotiation must complete within this number of ms
-   *
-   * @default 2000
-   * @deprecated use outboundStreamProtocolNegotiationTimeout or inboundStreamProtocolNegotiationTimeout instead
-   */
-  protocolNegotiationTimeout?: number
-
   /**
    * Outbound protocol negotiation must complete within this number of ms.
    *
@@ -250,8 +232,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.onDisconnect = this.onDisconnect.bind(this)
 
     // allow/deny lists
-    this.allow = (init.allow ?? []).map(str => multiaddrToIpNet(str))
-    this.deny = (init.deny ?? []).map(str => multiaddrToIpNet(str))
+    this.allow = (init.allow ?? []).map(str => multiaddrToIpNet(multiaddr(str)))
+    this.deny = (init.deny ?? []).map(str => multiaddrToIpNet(multiaddr(str)))
 
     this.incomingPendingConnections = 0
     this.maxIncomingPendingConnections = init.maxIncomingPendingConnections ?? defaultOptions.maxIncomingPendingConnections
@@ -639,8 +621,13 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
   acceptIncomingConnection (maConn: MultiaddrConnection): boolean {
     // check deny list
-    const denyConnection = this.deny.some(ma => {
-      return ma.contains(maConn.remoteAddr.nodeAddress().address)
+    const denyConnection = this.deny.some(ipNet => {
+      if (isNetworkAddress(maConn.remoteAddr)) {
+        const config = getNetConfig(maConn.remoteAddr)
+        return ipNet.contains(config.host)
+      }
+
+      return false
     })
 
     if (denyConnection) {
@@ -650,7 +637,12 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     // check allow list
     const allowConnection = this.allow.some(ipNet => {
-      return ipNet.contains(maConn.remoteAddr.nodeAddress().address)
+      if (isNetworkAddress(maConn.remoteAddr)) {
+        const config = getNetConfig(maConn.remoteAddr)
+        return ipNet.contains(config.host)
+      }
+
+      return true
     })
 
     if (allowConnection) {
@@ -665,13 +657,13 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       return false
     }
 
-    if (maConn.remoteAddr.isThinWaistAddress()) {
-      const host = maConn.remoteAddr.nodeAddress().address
+    if (isNetworkAddress(maConn.remoteAddr)) {
+      const config = getNetConfig(maConn.remoteAddr)
 
       try {
-        this.inboundConnectionRateLimiter.consume(host, 1)
+        this.inboundConnectionRateLimiter.consume(config.host, 1)
       } catch {
-        this.log('connection from %a refused - inboundConnectionThreshold exceeded by host %s', maConn.remoteAddr, host)
+        this.log('connection from %a refused - inboundConnectionThreshold exceeded by host %s', maConn.remoteAddr, config.host)
         return false
       }
     }

package/src/connection-manager/utils.ts

@@ -1,7 +1,7 @@
-import { multiaddr } from '@multiformats/multiaddr'
-import { convertToIpNet } from '@multiformats/multiaddr/convert'
+import { IpNet } from '@chainsafe/netmask'
+import { InvalidParametersError } from '@libp2p/interface'
+import { getNetConfig } from '@libp2p/utils'
 import { Circuit } from '@multiformats/multiaddr-matcher'
-import type { IpNet } from '@chainsafe/netmask'
 import type { Connection, AbortOptions, PeerId } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -63,32 +63,36 @@ export async function safelyCloseConnectionIfUnused (connection?: Connection, op
  * - /ipcidr/32 for IPv4
  * - /ipcidr/128 for IPv6
  *
- * @param {string | Multiaddr} ma - The multiaddr string or object to convert.
+ * @param {string | Multiaddr} ma - The multiaddr object to convert.
  * @returns {IpNet} The converted IpNet object.
  * @throws {Error} Throws an error if the multiaddr is not valid.
  */
-export function multiaddrToIpNet (ma: string | Multiaddr): IpNet {
-  try {
-    let parsedMa: Multiaddr
-    if (typeof ma === 'string') {
-      parsedMa = multiaddr(ma)
-    } else {
-      parsedMa = ma
-    }
+export function multiaddrToIpNet (ma: Multiaddr): IpNet {
+  const config = getNetConfig(ma)
+  let mask = config.cidr
 
-    const protoNames = new Set([...parsedMa.getComponents().map(component => component.name)])
+  if (config.type !== 'ip4' && config.type !== 'ip6') {
+    throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address`)
+  }
 
-    // Check if /ipcidr is already present
-    if (!protoNames.has('ipcidr')) {
-      const isIPv6 = protoNames.has('ip6')
-      const cidr = isIPv6 ? '/ipcidr/128' : '/ipcidr/32'
-      parsedMa = parsedMa.encapsulate(cidr)
+  // Check if /ipcidr is already present
+  if (mask == null) {
+    switch (config.type) {
+      case 'ip4': {
+        mask = 32
+        break
+      }
+      case 'ip6': {
+        mask = 128
+        break
+      }
+      default: {
+        throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address`)
+      }
     }
-
-    return convertToIpNet(parsedMa)
-  } catch (error) {
-    throw new Error(`Can't convert to IpNet, Invalid multiaddr format: ${ma}`)
   }
+
+  return new IpNet(config.host, mask)
 }
 
 /**

package/src/connection.ts

@@ -6,7 +6,7 @@ import { CONNECTION_CLOSE_TIMEOUT, PROTOCOL_NEGOTIATION_TIMEOUT } from './connec
 import { isDirect } from './connection-manager/utils.ts'
 import { MuxerUnavailableError } from './errors.ts'
 import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.ts'
-import type { AbortOptions, Logger, MessageStreamDirection, Connection as ConnectionInterface, Stream, NewStreamOptions, PeerId, ConnectionLimits, StreamMuxer, Metrics, PeerStore, MultiaddrConnection, MessageStreamEvents, MultiaddrConnectionTimeline, ConnectionStatus, MessageStream } from '@libp2p/interface'
+import type { AbortOptions, Logger, MessageStreamDirection, Connection as ConnectionInterface, Stream, NewStreamOptions, PeerId, ConnectionLimits, StreamMuxer, Metrics, PeerStore, MultiaddrConnection, MessageStreamEvents, MultiaddrConnectionTimeline, ConnectionStatus, MessageStream, StreamMiddleware } from '@libp2p/interface'
 import type { Registrar } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -177,7 +177,9 @@ export class Connection extends TypedEventEmitter<MessageStreamEvents> implement
 
       this.components.metrics?.trackProtocolStream(muxedStream)
 
-      return muxedStream
+      const middleware = this.components.registrar.getMiddleware(muxedStream.protocol)
+
+      return await this.runMiddlewareChain(muxedStream, this, middleware)
     } catch (err: any) {
       if (muxedStream.status === 'open') {
         muxedStream.abort(err)
@@ -235,12 +237,47 @@ export class Connection extends TypedEventEmitter<MessageStreamEvents> implement
         throw new LimitedConnectionError('Cannot open protocol stream on limited connection')
       }
 
-      await handler(muxedStream, this)
+      const middleware = this.components.registrar.getMiddleware(muxedStream.protocol)
+
+      middleware.push(async (stream, connection, next) => {
+        await handler(stream, connection)
+        next(stream, connection)
+      })
+
+      await this.runMiddlewareChain(muxedStream, this, middleware)
     } catch (err: any) {
       muxedStream.abort(err)
     }
   }
 
+  private async runMiddlewareChain (stream: Stream, connection: ConnectionInterface, middleware: StreamMiddleware[]): Promise<Stream> {
+    for (let i = 0; i < middleware.length; i++) {
+      const mw = middleware[i]
+      stream.log.trace('running middleware', i, mw)
+
+      // eslint-disable-next-line no-loop-func
+      await new Promise<void>((resolve, reject) => {
+        try {
+          const result = mw(stream, connection, (s, c) => {
+            stream = s
+            connection = c
+            resolve()
+          })
+
+          if (result instanceof Promise) {
+            result.catch(reject)
+          }
+        } catch (err) {
+          reject(err)
+        }
+      })
+
+      stream.log.trace('ran middleware', i, mw)
+    }
+
+    return stream
+  }
+
   /**
    * Close the connection
    */

package/src/get-peer.ts

@@ -1,6 +1,6 @@
 import { InvalidMultiaddrError, InvalidParametersError, isPeerId } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { isMultiaddr } from '@multiformats/multiaddr'
+import { CODE_P2P, isMultiaddr } from '@multiformats/multiaddr'
 import { PEER_ID } from '@multiformats/multiaddr-matcher'
 import type { PeerId } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -24,7 +24,7 @@ export function getPeerAddress (peer: PeerId | Multiaddr | Multiaddr[]): PeerAdd
   let peerId: PeerId | undefined
 
   if (multiaddrs.length > 0) {
-    const peerIdStr = multiaddrs[0].getPeerId()
+    const peerIdStr = multiaddrs[0].getComponents().findLast(c => c.code === CODE_P2P)?.value
     peerId = peerIdStr == null ? undefined : peerIdFromString(peerIdStr)
 
     // ensure PeerId is either not set or is consistent
@@ -33,7 +33,7 @@ export function getPeerAddress (peer: PeerId | Multiaddr | Multiaddr[]): PeerAdd
         throw new InvalidMultiaddrError('Invalid multiaddr')
       }
 
-      const maPeerIdStr = ma.getPeerId()
+      const maPeerIdStr = ma.getComponents().findLast(c => c.code === CODE_P2P)?.value
 
       if (maPeerIdStr == null) {
         if (peerId != null) {

package/src/libp2p.ts

@@ -4,7 +4,7 @@ import { defaultLogger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { persistentPeerStore } from '@libp2p/peer-store'
-import { isMultiaddr } from '@multiformats/multiaddr'
+import { CODE_P2P, isMultiaddr } from '@multiformats/multiaddr'
 import { MemoryDatastore } from 'datastore-core/memory'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
@@ -24,7 +24,7 @@ import { userAgent } from './user-agent.js'
 import * as pkg from './version.js'
 import type { Components } from './components.js'
 import type { Libp2p as Libp2pInterface, Libp2pInit } from './index.js'
-import type { PeerRouting, ContentRouting, Libp2pEvents, PendingDial, ServiceMap, AbortOptions, ComponentLogger, Logger, Connection, NewStreamOptions, Stream, Metrics, PeerId, PeerInfo, PeerStore, Topology, Libp2pStatus, IsDialableOptions, DialOptions, PublicKey, Ed25519PeerId, Secp256k1PeerId, RSAPublicKey, RSAPeerId, URLPeerId, Ed25519PublicKey, Secp256k1PublicKey, StreamHandler, StreamHandlerOptions } from '@libp2p/interface'
+import type { PeerRouting, ContentRouting, Libp2pEvents, PendingDial, ServiceMap, AbortOptions, ComponentLogger, Logger, Connection, NewStreamOptions, Stream, Metrics, PeerId, PeerInfo, PeerStore, Topology, Libp2pStatus, IsDialableOptions, DialOptions, PublicKey, Ed25519PeerId, Secp256k1PeerId, RSAPublicKey, RSAPeerId, URLPeerId, Ed25519PublicKey, Secp256k1PublicKey, StreamHandler, StreamHandlerOptions, StreamMiddleware } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter<Libp2pEvents> implements Libp2pInterface<T> {
@@ -119,8 +119,8 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
       connectionEncrypters: (init.connectionEncrypters ?? []).map((fn, index) => this.configureComponent(`connection-encryption-${index}`, fn(this.components))),
       streamMuxers: (init.streamMuxers ?? []).map((fn, index) => this.configureComponent(`stream-muxers-${index}`, fn(this.components))),
       inboundUpgradeTimeout: init.connectionManager?.inboundUpgradeTimeout,
-      inboundStreamProtocolNegotiationTimeout: init.connectionManager?.inboundStreamProtocolNegotiationTimeout ?? init.connectionManager?.protocolNegotiationTimeout,
-      outboundStreamProtocolNegotiationTimeout: init.connectionManager?.outboundStreamProtocolNegotiationTimeout ?? init.connectionManager?.protocolNegotiationTimeout,
+      inboundStreamProtocolNegotiationTimeout: init.connectionManager?.inboundStreamProtocolNegotiationTimeout,
+      outboundStreamProtocolNegotiationTimeout: init.connectionManager?.outboundStreamProtocolNegotiationTimeout,
       connectionCloseTimeout: init.connectionManager?.connectionCloseTimeout
     })
 
@@ -237,7 +237,7 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
 
       this.status = 'started'
       this.safeDispatchEvent('start', { detail: this })
-      this.log('libp2p has started')
+      this.log('libp2p has started with peer id %p', this.peerId)
     } catch (err: any) {
       this.log.error('An error occurred starting libp2p', err)
       // set status to 'started' so this.stop() will stop any running components
@@ -318,7 +318,7 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
 
   async hangUp (peer: PeerId | Multiaddr, options: AbortOptions = {}): Promise<void> {
     if (isMultiaddr(peer)) {
-      peer = peerIdFromString(peer.getPeerId() ?? '')
+      peer = peerIdFromString(peer.getComponents().findLast(c => c.code === CODE_P2P)?.value ?? '')
     }
 
     await this.components.connectionManager.closeConnections(peer, options)
@@ -401,6 +401,14 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
     this.components.registrar.unregister(id)
   }
 
+  use (protocol: string, middleware: StreamMiddleware | StreamMiddleware[]): void {
+    this.components.registrar.use(protocol, Array.isArray(middleware) ? middleware : [middleware])
+  }
+
+  unuse (protocol: string): void {
+    this.components.registrar.unuse(protocol)
+  }
+
   async isDialable (multiaddr: Multiaddr, options: IsDialableOptions = {}): Promise<boolean> {
     return this.components.connectionManager.isDialable(multiaddr, options)
   }

package/src/registrar.ts

@@ -1,7 +1,7 @@
 import { InvalidParametersError } from '@libp2p/interface'
-import { mergeOptions, trackedMap } from '@libp2p/utils'
+import { trackedMap } from '@libp2p/utils'
 import { DuplicateProtocolHandlerError, UnhandledProtocolError } from './errors.js'
-import type { IdentifyResult, Libp2pEvents, Logger, PeerUpdate, PeerId, PeerStore, Topology, StreamHandler, StreamHandlerRecord, StreamHandlerOptions, AbortOptions, Metrics } from '@libp2p/interface'
+import type { IdentifyResult, Libp2pEvents, Logger, PeerUpdate, PeerId, PeerStore, Topology, StreamHandler, StreamHandlerRecord, StreamHandlerOptions, AbortOptions, Metrics, StreamMiddleware } from '@libp2p/interface'
 import type { Registrar as RegistrarInterface } from '@libp2p/interface-internal'
 import type { ComponentLogger } from '@libp2p/logger'
 import type { TypedEventTarget } from 'main-event'
@@ -25,10 +25,12 @@ export class Registrar implements RegistrarInterface {
   private readonly topologies: Map<string, Map<string, Topology>>
   private readonly handlers: Map<string, StreamHandlerRecord>
   private readonly components: RegistrarComponents
+  private readonly middleware: Map<string, StreamMiddleware[]>
 
   constructor (components: RegistrarComponents) {
     this.components = components
     this.log = components.logger.forComponent('libp2p:registrar')
+    this.middleware = new Map()
     this.topologies = new Map()
     components.metrics?.registerMetricGroup('libp2p_registrar_topologies', {
       calculate: () => {
@@ -93,14 +95,13 @@ export class Registrar implements RegistrarInterface {
       throw new DuplicateProtocolHandlerError(`Handler already registered for protocol ${protocol}`)
     }
 
-    const options = mergeOptions.bind({ ignoreUndefined: true })({
-      maxInboundStreams: DEFAULT_MAX_INBOUND_STREAMS,
-      maxOutboundStreams: DEFAULT_MAX_OUTBOUND_STREAMS
-    }, opts)
-
     this.handlers.set(protocol, {
       handler,
-      options
+      options: {
+        maxInboundStreams: DEFAULT_MAX_INBOUND_STREAMS,
+        maxOutboundStreams: DEFAULT_MAX_OUTBOUND_STREAMS,
+        ...opts
+      }
     })
 
     // Add new protocol to self protocols in the peer store
@@ -164,6 +165,18 @@ export class Registrar implements RegistrarInterface {
     }
   }
 
+  use (protocol: string, middleware: StreamMiddleware[]): void {
+    this.middleware.set(protocol, middleware)
+  }
+
+  unuse (protocol: string): void {
+    this.middleware.delete(protocol)
+  }
+
+  getMiddleware (protocol: string): StreamMiddleware[] {
+    return this.middleware.get(protocol) ?? []
+  }
+
   /**
    * Remove a disconnected peer from the record
    */

package/src/upgrader.ts

@@ -2,6 +2,7 @@ import { InvalidMultiaddrError, InvalidPeerIdError } from '@libp2p/interface'
 import * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { trackedMap } from '@libp2p/utils'
+import { CODE_P2P } from '@multiformats/multiaddr'
 import { anySignal } from 'any-signal'
 import { setMaxListeners } from 'main-event'
 import { CustomProgressEvent } from 'progress-events'
@@ -222,7 +223,7 @@ export class Upgrader implements UpgraderInterface {
         outbound: true
       })
 
-      const idStr = maConn.remoteAddr.getPeerId()
+      const idStr = maConn.remoteAddr.getComponents().findLast(c => c.code === CODE_P2P)?.value
       let remotePeerId: PeerId | undefined
 
       if (idStr != null) {
@@ -284,7 +285,7 @@ export class Upgrader implements UpgraderInterface {
         cryptoProtocol = 'native'
         remotePeer = opts.remotePeer
       } else {
-        const peerIdString = maConn.remoteAddr.getPeerId()
+        const peerIdString = maConn.remoteAddr.getComponents().findLast(c => c.code === CODE_P2P)?.value
         let remotePeerFromMultiaddr: PeerId | undefined
 
         if (peerIdString != null) {

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.10.0-a02cb0461'
+export const version = '2.10.0-e8398d97e'
 export const name = 'js-libp2p'