libp2p 2.9.0 → 2.10.0-6059227cb

package/src/connection.ts

@@ -0,0 +1,353 @@
+import { connectionSymbol, LimitedConnectionError, ConnectionClosedError, TooManyOutboundProtocolStreamsError, TooManyInboundProtocolStreamsError, StreamCloseEvent } from '@libp2p/interface'
+import * as mss from '@libp2p/multistream-select'
+import { CODE_P2P } from '@multiformats/multiaddr'
+import { setMaxListeners, TypedEventEmitter } from 'main-event'
+import { CONNECTION_CLOSE_TIMEOUT, PROTOCOL_NEGOTIATION_TIMEOUT } from './connection-manager/constants.defaults.ts'
+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, StreamMiddleware } from '@libp2p/interface'
+import type { Registrar } from '@libp2p/interface-internal'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export interface ConnectionComponents {
+  peerStore: PeerStore
+  registrar: Registrar
+  metrics?: Metrics
+}
+
+export interface ConnectionInit {
+  id: string
+  maConn: MultiaddrConnection
+  stream: MessageStream
+  remotePeer: PeerId
+  direction?: MessageStreamDirection
+  muxer?: StreamMuxer
+  cryptoProtocol?: string
+  limits?: ConnectionLimits
+  outboundStreamProtocolNegotiationTimeout?: number
+  inboundStreamProtocolNegotiationTimeout?: number
+  closeTimeout?: number
+}
+
+/**
+ * An implementation of the js-libp2p connection.
+ * Any libp2p transport should use an upgrader to return this connection.
+ */
+export class Connection extends TypedEventEmitter<MessageStreamEvents> implements ConnectionInterface {
+  public readonly id: string
+  public readonly remoteAddr: Multiaddr
+  public readonly remotePeer: PeerId
+  public direction: MessageStreamDirection
+  public timeline: MultiaddrConnectionTimeline
+  public direct: boolean
+  public multiplexer?: string
+  public encryption?: string
+  public limits?: ConnectionLimits
+  public readonly log: Logger
+
+  private readonly maConn: MultiaddrConnection
+  private readonly muxer?: StreamMuxer
+  private readonly components: ConnectionComponents
+  private readonly outboundStreamProtocolNegotiationTimeout: number
+  private readonly inboundStreamProtocolNegotiationTimeout: number
+  private readonly closeTimeout: number
+
+  constructor (components: ConnectionComponents, init: ConnectionInit) {
+    super()
+
+    this.components = components
+
+    this.id = init.id
+    this.remoteAddr = init.maConn.remoteAddr
+    this.remotePeer = init.remotePeer
+    this.direction = init.direction ?? 'outbound'
+    this.timeline = init.maConn.timeline
+    this.encryption = init.cryptoProtocol
+    this.limits = init.limits
+    this.maConn = init.maConn
+    this.log = init.maConn.log
+    this.outboundStreamProtocolNegotiationTimeout = init.outboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT
+    this.inboundStreamProtocolNegotiationTimeout = init.inboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT
+    this.closeTimeout = init.closeTimeout ?? CONNECTION_CLOSE_TIMEOUT
+    this.direct = isDirect(init.maConn.remoteAddr)
+
+    this.onIncomingStream = this.onIncomingStream.bind(this)
+
+    if (this.remoteAddr.getComponents().find(component => component.code === CODE_P2P) == null) {
+      this.remoteAddr = this.remoteAddr.encapsulate(`/p2p/${this.remotePeer}`)
+    }
+
+    if (init.muxer != null) {
+      this.multiplexer = init.muxer.protocol
+      this.muxer = init.muxer
+      this.muxer.addEventListener('stream', this.onIncomingStream)
+    }
+
+    this.maConn.addEventListener('close', (evt) => {
+      this.dispatchEvent(new StreamCloseEvent(evt.local, evt.error))
+    })
+  }
+
+  readonly [Symbol.toStringTag] = 'Connection'
+
+  readonly [connectionSymbol] = true
+
+  get streams (): Stream[] {
+    return this.muxer?.streams ?? []
+  }
+
+  get status (): ConnectionStatus {
+    return this.maConn.status
+  }
+
+  /**
+   * Create a new stream over this connection
+   */
+  newStream = async (protocols: string[], options: NewStreamOptions = {}): Promise<Stream> => {
+    if (this.muxer == null) {
+      throw new MuxerUnavailableError('Connection is not multiplexed')
+    }
+
+    if (this.muxer.status !== 'open') {
+      throw new ConnectionClosedError(`The connection muxer is "${this.muxer.status}" and not "open"`)
+    }
+
+    if (this.maConn.status !== 'open') {
+      throw new ConnectionClosedError(`The connection is "${this.status}" and not "open"`)
+    }
+
+    if (this.limits != null && options?.runOnLimitedConnection !== true) {
+      throw new LimitedConnectionError('Cannot open protocol stream on limited connection')
+    }
+
+    if (!Array.isArray(protocols)) {
+      protocols = [protocols]
+    }
+
+    this.log.trace('starting new stream for protocols %s', protocols)
+    const muxedStream = await this.muxer.createStream({
+      ...options,
+
+      // most underlying transports only support negotiating a single protocol
+      // so only pass the early protocol if a single protocol has been requested
+      // otherwise fall back to mss
+      protocol: protocols.length === 1 ? protocols[0] : undefined
+    })
+    this.log.trace('started new stream %s for protocols %s', muxedStream.id, protocols)
+
+    try {
+      if (options.signal == null) {
+        muxedStream.log('no abort signal was passed while trying to negotiate protocols %s falling back to default timeout', protocols)
+
+        const signal = AbortSignal.timeout(this.outboundStreamProtocolNegotiationTimeout)
+        setMaxListeners(Infinity, signal)
+
+        options = {
+          ...options,
+          signal
+        }
+      }
+
+      if (muxedStream.protocol === '') {
+        muxedStream.log.trace('selecting protocol from protocols %s', protocols)
+
+        muxedStream.protocol = await mss.select(muxedStream, protocols, options)
+
+        muxedStream.log('negotiated protocol %s', muxedStream.protocol)
+      } else {
+        muxedStream.log('pre-negotiated protocol %s', muxedStream.protocol)
+      }
+
+      const outgoingLimit = findOutgoingStreamLimit(muxedStream.protocol, this.components.registrar, options)
+      const streamCount = countStreams(muxedStream.protocol, 'outbound', this)
+
+      if (streamCount > outgoingLimit) {
+        const err = new TooManyOutboundProtocolStreamsError(`Too many outbound protocol streams for protocol "${muxedStream.protocol}" - ${streamCount}/${outgoingLimit}`)
+        muxedStream.abort(err)
+
+        throw err
+      }
+
+      // If a protocol stream has been successfully negotiated and is to be passed to the application,
+      // the peer store should ensure that the peer is registered with that protocol
+      await this.components.peerStore.merge(this.remotePeer, {
+        protocols: [muxedStream.protocol]
+      })
+
+      this.components.metrics?.trackProtocolStream(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)
+      } else {
+        this.log.error('could not create new outbound stream on connection %s %a for protocols %s - %e', this.direction === 'inbound' ? 'from' : 'to', this.remoteAddr, protocols, err)
+      }
+
+      throw err
+    }
+  }
+
+  private async onIncomingStream (evt: CustomEvent<Stream>): Promise<void> {
+    const muxedStream = evt.detail
+
+    const signal = AbortSignal.timeout(this.inboundStreamProtocolNegotiationTimeout)
+    setMaxListeners(Infinity, signal)
+
+    muxedStream.log('start protocol negotiation, timing out after %dms', this.inboundStreamProtocolNegotiationTimeout)
+
+    try {
+      if (muxedStream.protocol === '') {
+        const protocols = this.components.registrar.getProtocols()
+
+        muxedStream.log.trace('selecting protocol from protocols %s', protocols)
+
+        muxedStream.protocol = await mss.handle(muxedStream, protocols, {
+          signal
+        })
+
+        muxedStream.log('negotiated protocol %s', muxedStream.protocol)
+      } else {
+        muxedStream.log('pre-negotiated protocol %s', muxedStream.protocol)
+      }
+
+      const incomingLimit = findIncomingStreamLimit(muxedStream.protocol, this.components.registrar)
+      const streamCount = countStreams(muxedStream.protocol, 'inbound', this)
+
+      if (streamCount > incomingLimit) {
+        throw new TooManyInboundProtocolStreamsError(`Too many inbound protocol streams for protocol "${muxedStream.protocol}" - limit ${incomingLimit}`)
+      }
+
+      // If a protocol stream has been successfully negotiated and is to be passed to the application,
+      // the peer store should ensure that the peer is registered with that protocol
+      await this.components.peerStore.merge(this.remotePeer, {
+        protocols: [muxedStream.protocol]
+      }, {
+        signal
+      })
+
+      this.components.metrics?.trackProtocolStream(muxedStream)
+
+      const { handler, options } = this.components.registrar.getHandler(muxedStream.protocol)
+
+      if (this.limits != null && options.runOnLimitedConnection !== true) {
+        throw new LimitedConnectionError('Cannot open protocol stream on limited connection')
+      }
+
+      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
+   */
+  async close (options: AbortOptions = {}): Promise<void> {
+    this.log('closing connection to %a', this.remoteAddr)
+
+    if (options.signal == null) {
+      const signal = AbortSignal.timeout(this.closeTimeout)
+      setMaxListeners(Infinity, signal)
+
+      options = {
+        ...options,
+        signal
+      }
+    }
+
+    await this.muxer?.close(options)
+    await this.maConn.close(options)
+  }
+
+  abort (err: Error): void {
+    this.muxer?.abort(err)
+    this.maConn.abort(err)
+  }
+}
+
+export function createConnection (components: ConnectionComponents, init: ConnectionInit): ConnectionInterface {
+  return new Connection(components, init)
+}
+
+function findIncomingStreamLimit (protocol: string, registrar: Registrar): number {
+  try {
+    const { options } = registrar.getHandler(protocol)
+
+    if (options.maxInboundStreams != null) {
+      return options.maxInboundStreams
+    }
+  } catch (err: any) {
+    if (err.name !== 'UnhandledProtocolError') {
+      throw err
+    }
+  }
+
+  return DEFAULT_MAX_INBOUND_STREAMS
+}
+
+function findOutgoingStreamLimit (protocol: string, registrar: Registrar, options: NewStreamOptions = {}): number {
+  try {
+    const { options } = registrar.getHandler(protocol)
+
+    if (options.maxOutboundStreams != null) {
+      return options.maxOutboundStreams
+    }
+  } catch (err: any) {
+    if (err.name !== 'UnhandledProtocolError') {
+      throw err
+    }
+  }
+
+  return options.maxOutboundStreams ?? DEFAULT_MAX_OUTBOUND_STREAMS
+}
+
+function countStreams (protocol: string, direction: 'inbound' | 'outbound', connection: Connection): number {
+  let streamCount = 0
+
+  connection.streams.forEach(stream => {
+    if (stream.direction === direction && stream.protocol === protocol) {
+      streamCount++
+    }
+  })
+
+  return streamCount
+}

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/index.ts

@@ -184,8 +184,8 @@ export type Libp2pOptions<T extends ServiceMap = ServiceMap> = Libp2pInit<T> & {
  * import { createLibp2p } from 'libp2p'
  * import { tcp } from '@libp2p/tcp'
  * import { mplex } from '@libp2p/mplex'
- * import { noise } from '@chainsafe/libp2p-noise'
- * import { yamux } from '@chainsafe/libp2p-yamux'
+ * import { noise } from '@libp2p/noise'
+ * import { yamux } from '@libp2p/yamux'
  *
  * // specify options
  * const options = {

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,9 @@ 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
     })
 
     // Setup the transport manager
@@ -236,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
@@ -304,9 +305,7 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
       throw new InvalidParametersError('no protocols were provided to open a stream')
     }
 
-    const connection = await this.dial(peer, options)
-
-    return connection.newStream(protocols, options)
+    return this.components.connectionManager.openStream(peer, protocols, options)
   }
 
   getMultiaddrs (): Multiaddr[] {
@@ -319,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)
@@ -402,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/peer-routing.ts

@@ -1,5 +1,5 @@
 import { NotFoundError } from '@libp2p/interface'
-import { createScalableCuckooFilter } from '@libp2p/utils/filters'
+import { createScalableCuckooFilter } from '@libp2p/utils'
 import merge from 'it-merge'
 import parallel from 'it-parallel'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'

package/src/random-walk.ts

@@ -2,7 +2,7 @@ import { randomBytes } from '@libp2p/crypto'
 import { anySignal } from 'any-signal'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import pDefer from 'p-defer'
-import { raceEvent } from 'race-event'
+import { pEvent } from 'p-event'
 import { raceSignal } from 'race-signal'
 import type { AbortOptions, ComponentLogger, Logger, PeerInfo, PeerRouting, Startable } from '@libp2p/interface'
 import type { RandomWalk as RandomWalkInterface } from '@libp2p/interface-internal'
@@ -68,12 +68,22 @@ export class RandomWalk extends TypedEventEmitter<RandomWalkEvents> implements R
         this.needNext = pDefer()
 
         // wait for a walk:peer or walk:error event
-        const event = await raceEvent<CustomEvent<PeerInfo>>(this, 'walk:peer', signal, {
-          errorEvent: 'walk:error'
+        const event = await pEvent<'walk:peer', CustomEvent<PeerInfo>>(this, 'walk:peer', {
+          signal,
+          rejectionEvents: [
+            'walk:error'
+          ]
         })
 
         yield event.detail
       }
+    } catch (err: any) {
+      // test for walk:error event
+      if (err.detail != null) {
+        throw err.detail
+      }
+
+      throw err
     } finally {
       signal.clear()
       this.walkers--