libp2p 0.43.4 → 0.44.0-0d46c78f

package/src/peer-routing.ts

@@ -6,52 +6,20 @@ import {
   uniquePeers,
   requirePeers
 } from './content-routing/utils.js'
-import { TimeoutController } from 'timeout-abort-controller'
 import merge from 'it-merge'
 import { pipe } from 'it-pipe'
 import first from 'it-first'
-import drain from 'it-drain'
 import filter from 'it-filter'
-import {
-  setDelayedInterval,
-  clearDelayedInterval
-// @ts-expect-error module with no types
-} from 'set-delayed-interval'
-import { setMaxListeners } from 'events'
 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/interface-peer-info'
 import type { PeerStore } from '@libp2p/interface-peer-store'
 
 const log = logger('libp2p:peer-routing')
 
-export interface RefreshManagerInit {
-  /**
-   * Whether to enable the Refresh manager
-   */
-  enabled?: boolean
-
-  /**
-   * Boot delay to start the Refresh Manager (in ms)
-   */
-  bootDelay?: number
-
-  /**
-   * Interval between each Refresh Manager run (in ms)
-   */
-  interval?: number
-
-  /**
-   * How long to let each refresh run (in ms)
-   */
-  timeout?: number
-}
-
 export interface PeerRoutingInit {
   routers?: PeerRouting[]
-  refreshManager?: RefreshManagerInit
 }
 
 export interface DefaultPeerRoutingComponents {
@@ -59,81 +27,13 @@ export interface DefaultPeerRoutingComponents {
   peerStore: PeerStore
 }
 
-export class DefaultPeerRouting implements PeerRouting, Startable {
+export class DefaultPeerRouting implements PeerRouting {
   private readonly components: DefaultPeerRoutingComponents
   private readonly routers: PeerRouting[]
-  private readonly refreshManagerInit: RefreshManagerInit
-  private timeoutId?: ReturnType<typeof setTimeout>
-  private started: boolean
-  private abortController?: TimeoutController
 
   constructor (components: DefaultPeerRoutingComponents, init: PeerRoutingInit) {
     this.components = components
     this.routers = init.routers ?? []
-    this.refreshManagerInit = init.refreshManager ?? {}
-    this.started = false
-
-    this._findClosestPeersTask = this._findClosestPeersTask.bind(this)
-  }
-
-  isStarted (): boolean {
-    return this.started
-  }
-
-  /**
-   * Start peer routing service.
-   */
-  async start (): Promise<void> {
-    if (this.started || this.routers.length === 0 || this.timeoutId != null || this.refreshManagerInit.enabled === false) {
-      return
-    }
-
-    this.timeoutId = setDelayedInterval(
-      this._findClosestPeersTask, this.refreshManagerInit.interval, this.refreshManagerInit.bootDelay
-    )
-
-    this.started = true
-  }
-
-  /**
-   * Recurrent task to find closest peers and add their addresses to the Address Book.
-   */
-  async _findClosestPeersTask (): Promise<void> {
-    if (this.abortController != null) {
-      // we are already running the query
-      return
-    }
-
-    try {
-      this.abortController = new TimeoutController(this.refreshManagerInit.timeout ?? 10e3)
-
-      // this controller may be used while dialing lots of peers so prevent MaxListenersExceededWarning
-      // appearing in the console
-      try {
-        // fails on node < 15.4
-        setMaxListeners?.(Infinity, this.abortController.signal)
-      } catch {}
-
-      // nb getClosestPeers adds the addresses to the address book
-      await drain(this.getClosestPeers(this.components.peerId.toBytes(), { signal: this.abortController.signal }))
-    } catch (err: any) {
-      log.error(err)
-    } finally {
-      this.abortController?.clear()
-      this.abortController = undefined
-    }
-  }
-
-  /**
-   * Stop peer routing service.
-   */
-  async stop (): Promise<void> {
-    clearDelayedInterval(this.timeoutId)
-
-    // abort query if it is in-flight
-    this.abortController?.abort()
-
-    this.started = false
   }
 
   /**

package/src/ping/constants.ts

@@ -3,3 +3,14 @@ export const PROTOCOL = '/ipfs/ping/1.0.0'
 export const PING_LENGTH = 32
 export const PROTOCOL_VERSION = '1.0.0'
 export const PROTOCOL_NAME = 'ping'
+export const PROTOCOL_PREFIX = 'ipfs'
+export const TIMEOUT = 10000
+
+// See https://github.com/libp2p/specs/blob/d4b5fb0152a6bb86cfd9ea/ping/ping.md?plain=1#L38-L43
+// The dialing peer MUST NOT keep more than one outbound stream for the ping protocol per peer.
+// The listening peer SHOULD accept at most two streams per peer since cross-stream behavior is
+// non-linear and stream writes occur asynchronously. The listening peer may perceive the
+// dialing peer closing and opening the wrong streams (for instance, closing stream B and
+// opening stream A even though the dialing peer is opening stream B and closing stream A).
+export const MAX_INBOUND_STREAMS = 2
+export const MAX_OUTBOUND_STREAMS = 1

package/src/ping/index.ts

@@ -5,28 +5,33 @@ import { randomBytes } from '@libp2p/crypto'
 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 { PROTOCOL_PREFIX, PROTOCOL_NAME, PING_LENGTH, PROTOCOL_VERSION, TIMEOUT, MAX_INBOUND_STREAMS, MAX_OUTBOUND_STREAMS } from './constants.js'
 import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { abortableDuplex } from 'abortable-iterator'
-import { TimeoutController } from 'timeout-abort-controller'
 import type { Stream } from '@libp2p/interface-connection'
 import { setMaxListeners } from 'events'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import { anySignal } from 'any-signal'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:ping')
 
+export interface PingService {
+  ping: (peer: PeerId | Multiaddr | Multiaddr[], options?: AbortOptions) => Promise<number>
+}
+
 export interface PingServiceInit {
-  protocolPrefix: string
-  maxInboundStreams: number
-  maxOutboundStreams: number
+  protocolPrefix?: string
+  maxInboundStreams?: number
+  maxOutboundStreams?: number
 
   /**
    * How long we should wait for a ping response
    */
-  timeout: number
+  timeout?: number
 }
 
 export interface PingServiceComponents {
@@ -34,23 +39,27 @@ export interface PingServiceComponents {
   connectionManager: ConnectionManager
 }
 
-export class PingService implements Startable {
+class DefaultPingService implements Startable, PingService {
   public readonly protocol: string
   private readonly components: PingServiceComponents
   private started: boolean
-  private readonly init: PingServiceInit
+  private readonly timeout: number
+  private readonly maxInboundStreams: number
+  private readonly maxOutboundStreams: number
 
   constructor (components: PingServiceComponents, init: PingServiceInit) {
     this.components = components
     this.started = false
-    this.protocol = `/${init.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
-    this.init = init
+    this.protocol = `/${init.protocolPrefix ?? PROTOCOL_PREFIX}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
+    this.timeout = init.timeout ?? TIMEOUT
+    this.maxInboundStreams = init.maxInboundStreams ?? MAX_INBOUND_STREAMS
+    this.maxOutboundStreams = init.maxOutboundStreams ?? MAX_OUTBOUND_STREAMS
   }
 
   async start (): Promise<void> {
     await this.components.registrar.handle(this.protocol, this.handleMessage, {
-      maxInboundStreams: this.init.maxInboundStreams,
-      maxOutboundStreams: this.init.maxOutboundStreams
+      maxInboundStreams: this.maxInboundStreams,
+      maxOutboundStreams: this.maxOutboundStreams
     })
     this.started = true
   }
@@ -82,26 +91,20 @@ export class PingService implements Startable {
    * @param {PeerId|Multiaddr} peer
    * @returns {Promise<number>}
    */
-  async ping (peer: PeerId, options: AbortOptions = {}): Promise<number> {
+  async ping (peer: PeerId | Multiaddr | Multiaddr[], options: AbortOptions = {}): Promise<number> {
     log('dialing %s to %p', this.protocol, peer)
 
     const start = Date.now()
     const data = randomBytes(PING_LENGTH)
     const connection = await this.components.connectionManager.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
+    const signal = anySignal([AbortSignal.timeout(this.timeout), options?.signal])
 
-      try {
-        // fails on node < 15.4
-        setMaxListeners?.(Infinity, timeoutController.signal)
-      } catch {}
-    }
+    try {
+      // fails on node < 15.4
+      setMaxListeners?.(Infinity, signal)
+    } catch {}
 
     try {
       stream = await connection.newStream([this.protocol], {
@@ -124,13 +127,14 @@ export class PingService implements Startable {
 
       return end - start
     } finally {
-      if (timeoutController != null) {
-        timeoutController.clear()
-      }
-
       if (stream != null) {
         stream.close()
       }
+      signal.clear()
     }
   }
 }
+
+export function pingService (init: PingServiceInit = {}): (components: PingServiceComponents) => PingService {
+  return (components) => new DefaultPingService(components, init)
+}

package/src/registrar.ts

@@ -4,10 +4,12 @@ import { codes } from './errors.js'
 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, PeerStore } from '@libp2p/interface-peer-store'
+import type { PeerStore } from '@libp2p/interface-peer-store'
 import type { Connection } from '@libp2p/interface-connection'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { PeerId } from '@libp2p/interface-peer-id'
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents, PeerUpdate } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:registrar')
 
@@ -18,6 +20,7 @@ export interface RegistrarComponents {
   peerId: PeerId
   connectionManager: ConnectionManager
   peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 /**
@@ -34,19 +37,16 @@ export class DefaultRegistrar implements Registrar {
     this.components = components
 
     this._onDisconnect = this._onDisconnect.bind(this)
-    this._onProtocolChange = this._onProtocolChange.bind(this)
+    this._onPeerUpdate = this._onPeerUpdate.bind(this)
     this._onConnect = this._onConnect.bind(this)
 
-    this.components.connectionManager.addEventListener('peer:disconnect', this._onDisconnect)
-    this.components.connectionManager.addEventListener('peer:connect', this._onConnect)
-
-    // happens after identify
-    this.components.peerStore.addEventListener('change:protocols', this._onProtocolChange)
+    this.components.events.addEventListener('connection:close', this._onDisconnect)
+    this.components.events.addEventListener('connection:open', this._onConnect)
+    this.components.events.addEventListener('peer:update', this._onPeerUpdate)
   }
 
   getProtocols (): string[] {
     return Array.from(new Set<string>([
-      ...this.topologies.keys(),
       ...this.handlers.keys()
     ])).sort()
   }
@@ -91,8 +91,10 @@ export class DefaultRegistrar implements Registrar {
       options
     })
 
-    // Add new protocols to self protocols in the Protobook
-    await this.components.peerStore.protoBook.add(this.components.peerId, [protocol])
+    // Add new protocol to self protocols in the peer store
+    await this.components.peerStore.merge(this.components.peerId, {
+      protocols: [protocol]
+    })
   }
 
   /**
@@ -106,8 +108,10 @@ export class DefaultRegistrar implements Registrar {
       this.handlers.delete(protocol)
     })
 
-    // Remove protocols from self protocols in the Protobook
-    await this.components.peerStore.protoBook.remove(this.components.peerId, protocolList)
+    // Update self protocols in the peer store
+    await this.components.peerStore.patch(this.components.peerId, {
+      protocols: protocolList
+    })
   }
 
   /**
@@ -158,9 +162,9 @@ export class DefaultRegistrar implements Registrar {
   _onDisconnect (evt: CustomEvent<Connection>): void {
     const connection = evt.detail
 
-    void this.components.peerStore.protoBook.get(connection.remotePeer)
-      .then(peerProtocols => {
-        for (const protocol of peerProtocols) {
+    void this.components.peerStore.get(connection.remotePeer)
+      .then(peer => {
+        for (const protocol of peer.protocols) {
           const topologies = this.topologies.get(protocol)
 
           if (topologies == null) {
@@ -174,7 +178,7 @@ export class DefaultRegistrar implements Registrar {
         }
       })
       .catch(err => {
-        log.error(err)
+        log.error('could not inform topologies of disconnecting peer %p', connection.remotePeer, err)
       })
   }
 
@@ -185,9 +189,9 @@ export class DefaultRegistrar implements Registrar {
   _onConnect (evt: CustomEvent<Connection>): void {
     const connection = evt.detail
 
-    void this.components.peerStore.protoBook.get(connection.remotePeer)
-      .then(peerProtocols => {
-        for (const protocol of peerProtocols) {
+    void this.components.peerStore.get(connection.remotePeer)
+      .then(peer => {
+        for (const protocol of peer.protocols) {
           const topologies = this.topologies.get(protocol)
 
           if (topologies == null) {
@@ -201,17 +205,17 @@ export class DefaultRegistrar implements Registrar {
         }
       })
       .catch(err => {
-        log.error(err)
+        log.error('could not inform topologies of connecting peer %p', connection.remotePeer, err)
       })
   }
 
   /**
    * Check if a new peer support the multicodecs for this topology
    */
-  _onProtocolChange (evt: CustomEvent<PeerProtocolsChangeData>): void {
-    const { peerId, protocols, oldProtocols } = evt.detail
-    const removed = oldProtocols.filter(protocol => !protocols.includes(protocol))
-    const added = protocols.filter(protocol => !oldProtocols.includes(protocol))
+  _onPeerUpdate (evt: CustomEvent<PeerUpdate>): void {
+    const { peer, previous } = evt.detail
+    const removed = (previous?.protocols ?? []).filter(protocol => !peer.protocols.includes(protocol))
+    const added = peer.protocols.filter(protocol => !(previous?.protocols ?? []).includes(protocol))
 
     for (const protocol of removed) {
       const topologies = this.topologies.get(protocol)
@@ -222,7 +226,7 @@ export class DefaultRegistrar implements Registrar {
       }
 
       for (const topology of topologies.values()) {
-        topology.onDisconnect(peerId)
+        topology.onDisconnect(peer.id)
       }
     }
 
@@ -235,12 +239,12 @@ export class DefaultRegistrar implements Registrar {
       }
 
       for (const topology of topologies.values()) {
-        const connection = this.components.connectionManager.getConnections(peerId)[0]
+        const connection = this.components.connectionManager.getConnections(peer.id)[0]
 
         if (connection == null) {
           continue
         }
-        topology.onConnect(peerId, connection)
+        topology.onConnect(peer.id, connection)
       }
     }
   }

package/src/transport-manager.ts

@@ -2,15 +2,18 @@ import { logger } from '@libp2p/logger'
 import { codes } from './errors.js'
 import { CodeError } from '@libp2p/interfaces/errors'
 import { FaultTolerance } from '@libp2p/interface-transport'
-import type { Listener, Transport, TransportManager, TransportManagerEvents, Upgrader } from '@libp2p/interface-transport'
+import type { Listener, Transport, TransportManager, Upgrader } from '@libp2p/interface-transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Connection } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import type { EventEmitter } from '@libp2p/interfaces/events'
 import type { Startable } from '@libp2p/interfaces/startable'
 import { trackedMap } from '@libp2p/tracked-map'
 import type { Metrics } from '@libp2p/interface-metrics'
 import type { AddressManager } from '@libp2p/interface-address-manager'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { PeerId } from '@libp2p/interface-peer-id'
 
 const log = logger('libp2p:transports')
 
@@ -22,9 +25,12 @@ export interface DefaultTransportManagerComponents {
   metrics?: Metrics
   addressManager: AddressManager
   upgrader: Upgrader
+  events: EventEmitter<Libp2pEvents>
+  peerId: PeerId
+  peerStore: PeerStore
 }
 
-export class DefaultTransportManager extends EventEmitter<TransportManagerEvents> implements TransportManager, Startable {
+export class DefaultTransportManager implements TransportManager, Startable {
   private readonly components: DefaultTransportManagerComponents
   private readonly transports: Map<string, Transport>
   private readonly listeners: Map<string, Listener[]>
@@ -32,8 +38,6 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
   private started: boolean
 
   constructor (components: DefaultTransportManagerComponents, init: TransportManagerInit = {}) {
-    super()
-
     this.components = components
     this.started = false
     this.transports = new Map<string, Transport>()
@@ -71,13 +75,15 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
     return this.started
   }
 
-  async start (): Promise<void> {
+  start (): void {
+    this.started = true
+  }
+
+  async afterStart (): Promise<void> {
     // Listen on the provided transports for the provided addresses
     const addrs = this.components.addressManager.getListenAddrs()
 
     await this.listen(addrs)
-
-    this.started = true
   }
 
   /**
@@ -151,6 +157,13 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
     return Array.of(...this.transports.values())
   }
 
+  /**
+   * Returns all the listener instances
+   */
+  getListeners (): Listener[] {
+    return Array.of(...this.listeners.values()).flat()
+  }
+
   /**
    * Finds a transport that matches the given Multiaddr
    */
@@ -186,7 +199,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
           upgrader: this.components.upgrader
         })
 
-        let listeners = this.listeners.get(key)
+        let listeners: Listener[] = this.listeners.get(key) ?? []
 
         if (listeners == null) {
           listeners = []
@@ -197,14 +210,35 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
 
         // Track listen/close events
         listener.addEventListener('listening', () => {
-          this.dispatchEvent(new CustomEvent<Listener>('listener:listening', {
-            detail: listener
-          }))
+          this.components.peerStore.patch(this.components.peerId, {
+            multiaddrs: this.getAddrs()
+          })
+            .then(() => {
+              this.components.events.safeDispatchEvent('transport:listening', {
+                detail: listener
+              })
+            })
+            .catch(err => {
+              log.error('error while updating peer record after listener began listening', err)
+            })
         })
         listener.addEventListener('close', () => {
-          this.dispatchEvent(new CustomEvent<Listener>('listener:close', {
-            detail: listener
-          }))
+          const index = listeners.findIndex(l => l === listener)
+
+          // remove the listener
+          listeners.splice(index, 1)
+
+          this.components.peerStore.patch(this.components.peerId, {
+            multiaddrs: this.getAddrs()
+          })
+            .then(() => {
+              this.components.events.safeDispatchEvent('transport:close', {
+                detail: listener
+              })
+            })
+            .catch(err => {
+              log.error('error while updating peer record after listener stopped listening', err)
+            })
         })
 
         // We need to attempt to listen on everything