libp2p 0.44.0-e3deaa40 → 0.44.0-ed2fa794

package/src/circuit-relay/transport/discovery.ts

@@ -91,7 +91,7 @@ export class RelayDiscovery extends EventEmitter<RelayDiscoveryEvents> implement
     log('searching peer store for relays')
     const peers = (await this.peerStore.all())
       // filter by a list of peers supporting RELAY_V2_HOP and ones we are not listening on
-      .filter(({ id, protocols }) => protocols.includes(RELAY_V2_HOP_CODEC))
+      .filter(({ protocols }) => protocols.includes(RELAY_V2_HOP_CODEC))
       .sort(() => Math.random() - 0.5)
 
     for (const peer of peers) {
@@ -112,11 +112,11 @@ export class RelayDiscovery extends EventEmitter<RelayDiscoveryEvents> implement
           const peerId = provider.id
 
           found++
-          log('found relay peer %p in content routing', peerId)
           await this.peerStore.merge(peerId, {
             multiaddrs: provider.multiaddrs
           })
 
+          log('found relay peer %p in content routing', peerId)
           this.safeDispatchEvent('relay:discover', { detail: peerId })
         }
       }

package/src/circuit-relay/transport/index.ts

@@ -84,7 +84,6 @@ class CircuitRelayTransport implements Transport {
   private readonly upgrader: Upgrader
   private readonly addressManager: AddressManager
   private readonly connectionGater: ConnectionGater
-  private readonly events: EventEmitter<Libp2pEvents>
   private readonly reservationStore: ReservationStore
   private started: boolean
 
@@ -96,7 +95,6 @@ class CircuitRelayTransport implements Transport {
     this.upgrader = components.upgrader
     this.addressManager = components.addressManager
     this.connectionGater = components.connectionGater
-    this.events = components.events
 
     if (init.discoverRelays != null && init.discoverRelays > 0) {
       this.discovery = new RelayDiscovery(components)
@@ -170,7 +168,7 @@ class CircuitRelayTransport implements Transport {
     const destinationId = destinationAddr.getPeerId()
 
     if (relayId == null || destinationId == null) {
-      const errMsg = 'Circuit relay dial failed as addresses did not have peer id'
+      const errMsg = `Circuit relay dial to ${ma.toString()} failed as address did not have peer ids`
       log.error(errMsg)
       throw new CodeError(errMsg, codes.ERR_RELAYED_DIAL)
     }
@@ -203,7 +201,7 @@ class CircuitRelayTransport implements Transport {
         disconnectOnFailure
       })
     } catch (err: any) {
-      log.error('Circuit relay dial failed', err)
+      log.error(`Circuit relay dial to destination ${destinationPeer.toString()} via relay ${relayPeer.toString()} failed`, err)
       disconnectOnFailure && await relayConnection.close()
       throw err
     }
@@ -244,7 +242,7 @@ class CircuitRelayTransport implements Transport {
       log('new outbound connection %s', maConn.remoteAddr)
       return await this.upgrader.upgradeOutbound(maConn)
     } catch (err) {
-      log.error('Circuit relay dial failed', err)
+      log.error(`Circuit relay dial to destination ${destinationPeer.toString()} via relay ${connection.remotePeer.toString()} failed`, err)
       disconnectOnFailure && await connection.close()
       throw err
     }
@@ -256,8 +254,7 @@ class CircuitRelayTransport implements Transport {
   createListener (options: CreateListenerOptions): Listener {
     return createListener({
       connectionManager: this.connectionManager,
-      relayStore: this.reservationStore,
-      events: this.events
+      relayStore: this.reservationStore
     })
   }
 

package/src/circuit-relay/transport/listener.ts

@@ -7,47 +7,57 @@ import type { ReservationStore } from './reservation-store.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import { PeerMap } from '@libp2p/peer-collections'
 import { logger } from '@libp2p/logger'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
+import { peerIdFromString } from '@libp2p/peer-id'
+import type { Connection } from '@libp2p/interface-connection'
+import { CodeError } from '@libp2p/interfaces/errors'
 
 const log = logger('libp2p:circuit-relay:transport:listener')
 
 export interface CircuitRelayTransportListenerComponents {
   connectionManager: ConnectionManager
   relayStore: ReservationStore
-  events: EventEmitter<Libp2pEvents>
 }
 
 class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> implements Listener {
   private readonly connectionManager: ConnectionManager
   private readonly relayStore: ReservationStore
-  private readonly listeningAddrs: PeerMap<Multiaddr>
-  private readonly events: EventEmitter<Libp2pEvents>
+  private readonly listeningAddrs: PeerMap<Multiaddr[]>
 
   constructor (components: CircuitRelayTransportListenerComponents) {
     super()
 
     this.connectionManager = components.connectionManager
     this.relayStore = components.relayStore
-    this.events = components.events
     this.listeningAddrs = new PeerMap()
 
     // remove listening addrs when a relay is removed
     this.relayStore.addEventListener('relay:removed', (evt) => {
       this.#removeRelayPeer(evt.detail)
     })
-
-    // remove listening addrs when a peer disconnects
-    this.events.addEventListener('connection:close', (evt) => {
-      this.#removeRelayPeer(evt.detail.remotePeer)
-    })
   }
 
   async listen (addr: Multiaddr): Promise<void> {
     log('listen on %s', addr)
 
-    const addrString = addr.toString().split('/p2p-circuit').find(a => a !== '')
-    const ma = multiaddr(addrString)
-    const relayConn = await this.connectionManager.openConnection(ma)
+    const relayPeerStr = addr.getPeerId()
+    let relayConn: Connection | undefined
+
+    // check if we already have a connection to the relay
+    if (relayPeerStr != null) {
+      const relayPeer = peerIdFromString(relayPeerStr)
+      const connections = this.connectionManager.getConnectionsMap().get(relayPeer) ?? []
+
+      if (connections.length > 0) {
+        relayConn = connections[0]
+      }
+    }
+
+    // open a new connection as we don't already have one
+    if (relayConn == null) {
+      const addrString = addr.toString().split('/p2p-circuit').find(a => a !== '')
+      const ma = multiaddr(addrString)
+      relayConn = await this.connectionManager.openConnection(ma)
+    }
 
     if (!this.relayStore.hasReservation(relayConn.remotePeer)) {
       // addRelay calls transportManager.listen which calls this listen method
@@ -55,31 +65,27 @@ class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> impleme
       return
     }
 
+    const reservation = this.relayStore.getReservation(relayConn.remotePeer)
+
+    if (reservation == null) {
+      throw new CodeError('Did not have reservation after making reservation', 'ERR_NO_RESERVATION')
+    }
+
     if (this.listeningAddrs.has(relayConn.remotePeer)) {
       log('already listening on relay %p', relayConn.remotePeer)
       return
     }
 
-    this.listeningAddrs.set(relayConn.remotePeer, addr)
+    // add all addresses from the relay reservation
+    this.listeningAddrs.set(relayConn.remotePeer, reservation.addrs.map(buf => {
+      return multiaddr(buf).encapsulate('/p2p-circuit')
+    }))
+
     this.safeDispatchEvent('listening', {})
   }
 
-  /**
-   * Get fixed up multiaddrs
-   *
-   * NOTE: This method will grab the peers multiaddrs and expand them such that:
-   *
-   * a) If it's an existing /p2p-circuit address for a specific relay i.e.
-   * `/ip4/0.0.0.0/tcp/0/ipfs/QmRelay/p2p-circuit` this method will expand the
-   * address to `/ip4/0.0.0.0/tcp/0/ipfs/QmRelay/p2p-circuit/ipfs/QmPeer` where
-   * `QmPeer` is this peers id
-   * b) If it's not a /p2p-circuit address, it will encapsulate the address as a /p2p-circuit
-   * addr, such when dialing over a relay with this address, it will create the circuit using
-   * the encapsulated transport address. This is useful when for example, a peer should only
-   * be dialed over TCP rather than any other transport
-   */
   getAddrs (): Multiaddr[] {
-    return [...this.listeningAddrs.values()]
+    return [...this.listeningAddrs.values()].flat()
   }
 
   async close (): Promise<void> {

package/src/circuit-relay/transport/reservation-store.ts

@@ -96,8 +96,8 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     // When a peer disconnects, if we had a reservation on that peer
     // remove the reservation and multiaddr and maybe trigger search
     // for new relays
-    this.events.addEventListener('connection:close', (evt) => {
-      this.removeRelay(evt.detail.remotePeer)
+    this.events.addEventListener('peer:disconnect', (evt) => {
+      this.#removeRelay(evt.detail)
     })
   }
 
@@ -125,15 +125,15 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
    * on the remote peer
    */
   async addRelay (peerId: PeerId, type: RelayType): Promise<void> {
-    log('add relay', this.reserveQueue.size)
+    if (this.peerId.equals(peerId)) {
+      log('not trying to use self as relay')
+      return
+    }
+
+    log('add relay %p', peerId)
 
     await this.reserveQueue.add(async () => {
       try {
-        if (this.peerId.equals(peerId)) {
-          log('not trying to use self as relay')
-          return
-        }
-
         // allow refresh of an existing reservation if it is about to expire
         const existingReservation = this.reservations.get(peerId)
 
@@ -181,6 +181,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
           })
         }, timeoutDuration)
 
+        // we've managed to create a reservation successfully
         this.reservations.set(peerId, {
           timeout,
           reservation,
@@ -197,13 +198,13 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
           }
         })
 
-        await this.transportManager.listen(
-          reservation.addrs.map(ma => {
-            return multiaddr(ma).encapsulate('/p2p-circuit')
-          })
-        )
+        // listen on multiaddr that only the circuit transport is listening for
+        await this.transportManager.listen([multiaddr(`/p2p/${peerId.toString()}/p2p-circuit`)])
       } catch (err) {
         log.error('could not reserve slot on %p', peerId, err)
+
+        // if listening failed, remove the reservation
+        this.reservations.delete(peerId)
       }
     })
   }
@@ -212,6 +213,10 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     return this.reservations.has(peerId)
   }
 
+  getReservation (peerId: PeerId): Reservation | undefined {
+    return this.reservations.get(peerId)?.reservation
+  }
+
   async #createReservation (connection: Connection): Promise<Reservation> {
     log('requesting reservation from %s', connection.remotePeer)
     const stream = await connection.newStream(RELAY_V2_HOP_CODEC)
@@ -243,14 +248,14 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
   /**
    * Remove listen relay
    */
-  removeRelay (peerId: PeerId): void {
+  #removeRelay (peerId: PeerId): void {
     const existingReservation = this.reservations.get(peerId)
 
     if (existingReservation == null) {
       return
     }
 
-    log('removing relay %p', peerId)
+    log('connection to relay %p closed, removing reservation from local store', peerId)
 
     clearTimeout(existingReservation.timeout)
     this.reservations.delete(peerId)
@@ -258,6 +263,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     this.safeDispatchEvent('relay:removed', { detail: peerId })
 
     if (this.reservations.size < this.maxDiscoveredRelays) {
+      log('not enough relays %d/%d', this.reservations.size, this.maxDiscoveredRelays)
       this.safeDispatchEvent('relay:not-enough-relays', {})
     }
   }

package/src/config.ts

@@ -24,62 +24,7 @@ const DefaultConfig: Partial<Libp2pInit> = {
   },
   transportManager: {
     faultTolerance: FaultTolerance.FATAL_ALL
-  },
-  peerRouting: {
-    refreshManager: {
-      enabled: true,
-      interval: 6e5,
-      bootDelay: 10e3
-    }
   }
-/*
-
-  nat: {
-    enabled: true,
-    ttl: 7200,
-    keepAlive: true
-  },
-  identify: {
-    protocolPrefix: 'ipfs',
-    host: {
-      agentVersion: AGENT_VERSION
-    },
-    // https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/identify/id.go#L48
-    timeout: 60000,
-    maxInboundStreams: 1,
-    maxOutboundStreams: 1,
-    maxPushIncomingStreams: 1,
-    maxPushOutgoingStreams: 1,
-    maxObservedAddresses: 10
-  },
-  ping: {
-    protocolPrefix: 'ipfs',
-    // 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).
-    maxInboundStreams: 2,
-    maxOutboundStreams: 1,
-    timeout: 10000
-  },
-  fetch: {
-    protocolPrefix: 'libp2p',
-    maxInboundStreams: 1,
-    maxOutboundStreams: 1,
-    timeout: 10000
-  },
-  autonat: {
-    protocolPrefix: 'libp2p',
-    maxInboundStreams: 1,
-    maxOutboundStreams: 1,
-    timeout: 30000,
-    startupDelay: 5000,
-    refreshInterval: 60000
-  }
-
-*/
 }
 
 export function validateConfig <T extends ServiceMap = {}> (opts: RecursivePartial<Libp2pInit<T>>): Libp2pInit<T> {

package/src/connection-manager/dial-queue.ts

@@ -23,6 +23,7 @@ import { combineSignals, resolveMultiaddrs } from './utils.js'
 import pDefer from 'p-defer'
 import { ClearableSignal, anySignal } from 'any-signal'
 import type { AddressSorter } from '@libp2p/interface-libp2p'
+import { setMaxListeners } from 'events'
 
 const log = logger('libp2p:connection-manager:dial-queue')
 
@@ -100,6 +101,11 @@ export class DialQueue {
     this.transportManager = components.transportManager
     this.shutDownController = new AbortController()
 
+    try {
+      // This emitter gets listened to a lot
+      setMaxListeners?.(Infinity, this.shutDownController.signal)
+    } catch {}
+
     this.pendingDialCount = components.metrics?.registerMetric('libp2p_dialler_pending_dials')
     this.inProgressDialCount = components.metrics?.registerMetric('libp2p_dialler_in_progress_dials')
     this.pendingDials = []
@@ -258,6 +264,11 @@ export class DialQueue {
       ]
     )
 
+    try {
+      // This emitter gets listened to a lot
+      setMaxListeners?.(Infinity, signal)
+    } catch {}
+
     return signal
   }
 

package/src/index.ts

@@ -32,7 +32,6 @@ import type { Components } from './components.js'
 import type { Libp2p, ServiceMap } from '@libp2p/interface-libp2p'
 import type { KeyChainInit } from '@libp2p/keychain'
 import type { AddressManagerInit } from './address-manager/index.js'
-import type { PeerRoutingInit } from './peer-routing.js'
 import type { ConnectionManagerInit } from './connection-manager/index.js'
 import type { PersistentPeerStoreInit } from '@libp2p/peer-store'
 
@@ -81,11 +80,6 @@ export interface Libp2pInit<T extends ServiceMap = {}> {
    */
   peerStore: PersistentPeerStoreInit
 
-  /**
-   * libp2p Peer routing service configuration
-   */
-  peerRouting: PeerRoutingInit
-
   /**
    * keychain configuration
    */
@@ -134,11 +128,12 @@ export type Libp2pOptions<T extends ServiceMap = {}> = RecursivePartial<Libp2pIn
  * import { tcp } from '@libp2p/tcp'
  * import { mplex } from '@libp2p/mplex'
  * import { noise } from '@chainsafe/libp2p-noise'
+ * import { yamux } from '@chainsafe/libp2p-yamux'
  *
  * // specify options
  * const options = {
  *   transports: [tcp()],
- *   streamMuxers: [mplex()],
+ *   streamMuxers: [yamux(), mplex()],
  *   connectionEncryption: [noise()]
  * }
  *

package/src/libp2p.ts

@@ -137,7 +137,6 @@ export class Libp2pNode<T extends ServiceMap = {}> extends EventEmitter<Libp2pEv
     // Peer routers
     const peerRouters: PeerRouting[] = (init.peerRouters ?? []).map((fn, index) => this.configureComponent(`peer-router-${index}`, fn(this.components)))
     this.peerRouting = this.components.peerRouting = this.configureComponent('peerRouting', new DefaultPeerRouting(this.components, {
-      ...init.peerRouting,
       routers: peerRouters
     }))
 

package/src/peer-routing.ts

@@ -9,49 +9,17 @@ import {
 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'
-import { anySignal } from 'any-signal'
 
 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,83 +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?: AbortController
 
   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
-    }
-
-    this.abortController = new AbortController()
-
-    const signal = anySignal([this.abortController.signal, AbortSignal.timeout(this.refreshManagerInit.timeout ?? 10e3)])
-
-    try {
-      // this controller may be used while dialing lots of peers so prevent MaxListenersExceededWarning
-      // appearing in the console
-      try {
-        setMaxListeners?.(Infinity, signal)
-      } catch {}
-
-      // nb getClosestPeers adds the addresses to the address book
-      await drain(this.getClosestPeers(this.components.peerId.toBytes(), { signal }))
-    } catch (err: any) {
-      log.error(err)
-    } finally {
-      this.abortController?.abort()
-      this.abortController = undefined
-      signal.clear()
-    }
-  }
-
-  /**
-   * 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/transport-manager.ts

@@ -157,6 +157,13 @@ export class DefaultTransportManager implements TransportManager, Startable {
     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
    */
@@ -192,7 +199,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
           upgrader: this.components.upgrader
         })
 
-        let listeners = this.listeners.get(key)
+        let listeners: Listener[] = this.listeners.get(key) ?? []
 
         if (listeners == null) {
           listeners = []
@@ -216,6 +223,11 @@ export class DefaultTransportManager implements TransportManager, Startable {
             })
         })
         listener.addEventListener('close', () => {
+          const index = listeners.findIndex(l => l === listener)
+
+          // remove the listener
+          listeners.splice(index, 1)
+
           this.components.peerStore.patch(this.components.peerId, {
             multiaddrs: this.getAddrs()
           })

package/src/upgrader.ts

@@ -73,7 +73,6 @@ function findIncomingStreamLimit (protocol: string, registrar: Registrar): numbe
 function findOutgoingStreamLimit (protocol: string, registrar: Registrar): number | undefined {
   try {
     const { options } = registrar.getHandler(protocol)
-
     return options.maxOutboundStreams
   } catch (err: any) {
     if (err.code !== codes.ERR_NO_HANDLER_FOR_PROTOCOL) {
@@ -392,9 +391,10 @@ export class DefaultUpgrader implements Upgrader {
               const streamCount = countStreams(protocol, 'inbound', connection)
 
               if (streamCount === incomingLimit) {
-                muxedStream.abort(new CodeError(`Too many inbound protocol streams for protocol "${protocol}" - limit ${incomingLimit}`, codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS))
+                const err = new CodeError(`Too many inbound protocol streams for protocol "${protocol}" - limit ${incomingLimit}`, codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS)
+                muxedStream.abort(err)
 
-                return
+                throw err
               }
 
               // after the handshake the returned stream can have early data so override

package/src/upnp-nat/index.ts

@@ -50,7 +50,7 @@ export interface UPnPNATInit {
   /**
    * Whether to automatically refresh UPnP port mappings when their TTL is reached
    */
-  keepAlive: boolean
+  keepAlive?: boolean
 
   /**
    * Pass a value to use instead of auto-detection
@@ -205,7 +205,7 @@ class UPnPNAT implements Startable {
   }
 }
 
-export function uPnPNAT (init: UPnPNATInit): (components: UPnPNATComponents) => {} {
+export function uPnPNATService (init: UPnPNATInit = {}): (components: UPnPNATComponents) => {} {
   return (components: UPnPNATComponents) => {
     return new UPnPNAT(components, init)
   }

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.44.0-e3deaa40'
+export const version = '0.44.0-ed2fa794'
 export const name = 'libp2p'