libp2p 0.44.0 → 0.45.0-752db6d6

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

@@ -23,6 +23,8 @@ import { CIRCUIT_PROTO_CODE, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../
 import { RelayStoreInit, ReservationStore } from './reservation-store.js'
 import { RelayDiscovery, RelayDiscoveryComponents } from './discovery.js'
 import { CodeError } from '@libp2p/interfaces/errors'
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:circuit-relay:transport')
 
@@ -49,6 +51,7 @@ export interface CircuitRelayTransportComponents extends RelayDiscoveryComponent
   addressManager: AddressManager
   contentRouting: ContentRouting
   connectionGater: ConnectionGater
+  events: EventEmitter<Libp2pEvents>
 }
 
 interface ConnectOptions {
@@ -165,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)
     }
@@ -178,7 +181,9 @@ class CircuitRelayTransport implements Transport {
     let relayConnection = relayConnections[0]
 
     if (relayConnection == null) {
-      await this.peerStore.addressBook.add(relayPeer, [relayAddr])
+      await this.peerStore.merge(relayPeer, {
+        multiaddrs: [relayAddr]
+      })
       relayConnection = await this.connectionManager.openConnection(relayPeer, options)
       disconnectOnFailure = true
     }
@@ -196,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
     }
@@ -237,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
     }

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

@@ -1,4 +1,4 @@
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interfaces/events'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { Listener, ListenerEvents } from '@libp2p/interface-transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -7,6 +7,9 @@ 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 { 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')
 
@@ -18,7 +21,7 @@ export interface CircuitRelayTransportListenerComponents {
 class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> implements Listener {
   private readonly connectionManager: ConnectionManager
   private readonly relayStore: ReservationStore
-  private readonly listeningAddrs: PeerMap<Multiaddr>
+  private readonly listeningAddrs: PeerMap<Multiaddr[]>
 
   constructor (components: CircuitRelayTransportListenerComponents) {
     super()
@@ -31,19 +34,30 @@ class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> impleme
     this.relayStore.addEventListener('relay:removed', (evt) => {
       this.#removeRelayPeer(evt.detail)
     })
-
-    // remove listening addrs when a peer disconnects
-    this.connectionManager.addEventListener('peer:disconnect', (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
@@ -51,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)
-    this.dispatchEvent(new CustomEvent('listening'))
+    // 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> {
@@ -89,7 +99,7 @@ class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> impleme
 
     if (had) {
       // Announce listen addresses change
-      this.dispatchEvent(new CustomEvent('close'))
+      this.safeDispatchEvent('close', {})
     }
   }
 }

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

@@ -11,9 +11,10 @@ import { HopMessage, Status } from '../pb/index.js'
 import { getExpirationMilliseconds } from '../utils.js'
 import type { TransportManager } from '@libp2p/interface-transport'
 import type { Startable } from '@libp2p/interfaces/startable'
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interfaces/events'
 import type { PeerStore } from '@libp2p/interface-peer-store'
 import { multiaddr } from '@multiformats/multiaddr'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:circuit-relay:transport:reservation-store')
 
@@ -31,6 +32,7 @@ export interface RelayStoreComponents {
   connectionManager: ConnectionManager
   transportManager: TransportManager
   peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 export interface RelayStoreInit {
@@ -68,6 +70,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
   private readonly connectionManager: ConnectionManager
   private readonly transportManager: TransportManager
   private readonly peerStore: PeerStore
+  private readonly events: EventEmitter<Libp2pEvents>
   private readonly reserveQueue: PQueue
   private readonly reservations: PeerMap<RelayEntry>
   private readonly maxDiscoveredRelays: number
@@ -80,6 +83,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     this.connectionManager = components.connectionManager
     this.transportManager = components.transportManager
     this.peerStore = components.peerStore
+    this.events = components.events
     this.reservations = new PeerMap()
     this.maxDiscoveredRelays = init?.discoverRelays ?? 0
     this.started = false
@@ -92,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.connectionManager.addEventListener('peer:disconnect', (evt) => {
-      this.removeRelay(evt.detail.remotePeer)
+    this.events.addEventListener('peer:disconnect', (evt) => {
+      this.#removeRelay(evt.detail)
     })
   }
 
@@ -121,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)
 
@@ -177,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,
@@ -184,18 +189,22 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
         })
 
         // ensure we don't close the connection to the relay
-        await this.peerStore.tagPeer(peerId, RELAY_TAG, {
-          value: 1,
-          ttl: expiration
+        await this.peerStore.merge(peerId, {
+          tags: {
+            [RELAY_TAG]: {
+              value: 1,
+              ttl: expiration
+            }
+          }
         })
 
-        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)
       }
     })
   }
@@ -204,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)
@@ -235,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)
@@ -250,7 +263,8 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     this.safeDispatchEvent('relay:removed', { detail: peerId })
 
     if (this.reservations.size < this.maxDiscoveredRelays) {
-      this.dispatchEvent(new CustomEvent('relay:not-enough-relays'))
+      log('not enough relays %d/%d', this.reservations.size, this.maxDiscoveredRelays)
+      this.safeDispatchEvent('relay:not-enough-relays', {})
     }
   }
 }

package/src/components.ts

@@ -10,13 +10,14 @@ import type { PeerStore } from '@libp2p/interface-peer-store'
 import type { Registrar } from '@libp2p/interface-registrar'
 import type { TransportManager, Upgrader } from '@libp2p/interface-transport'
 import type { Datastore } from 'interface-datastore'
-import type { PubSub } from '@libp2p/interface-pubsub'
-import type { DualDHT } from '@libp2p/interface-dht'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
+import type { EventEmitter } from '@libp2p/interfaces/events'
 
-export interface Components {
+export interface Components extends Record<string, any>, Startable {
   peerId: PeerId
+  events: EventEmitter<Libp2pEvents>
   addressManager: AddressManager
   peerStore: PeerStore
   upgrader: Upgrader
@@ -29,12 +30,11 @@ export interface Components {
   datastore: Datastore
   connectionProtector?: ConnectionProtector
   metrics?: Metrics
-  dht?: DualDHT
-  pubsub?: PubSub
 }
 
 export interface ComponentsInit {
   peerId?: PeerId
+  events?: EventEmitter<Libp2pEvents>
   addressManager?: AddressManager
   peerStore?: PeerStore
   upgrader?: Upgrader
@@ -47,271 +47,108 @@ export interface ComponentsInit {
   peerRouting?: PeerRouting
   datastore?: Datastore
   connectionProtector?: ConnectionProtector
-  dht?: DualDHT
-  pubsub?: PubSub
 }
 
-export class DefaultComponents implements Components, Startable {
-  private _peerId?: PeerId
-  private _addressManager?: AddressManager
-  private _peerStore?: PeerStore
-  private _upgrader?: Upgrader
-  private _metrics?: Metrics
-  private _registrar?: Registrar
-  private _connectionManager?: ConnectionManager
-  private _transportManager?: TransportManager
-  private _connectionGater?: ConnectionGater
-  private _contentRouting?: ContentRouting
-  private _peerRouting?: PeerRouting
-  private _datastore?: Datastore
-  private _connectionProtector?: ConnectionProtector
-  private _dht?: DualDHT
-  private _pubsub?: PubSub
+class DefaultComponents implements Startable {
+  public components: Record<string, any> = {}
   private _started = false
 
   constructor (init: ComponentsInit = {}) {
-    this._peerId = init.peerId
-    this._addressManager = init.addressManager
-    this._peerStore = init.peerStore
-    this._upgrader = init.upgrader
-    this._metrics = init.metrics
-    this._registrar = init.registrar
-    this._connectionManager = init.connectionManager
-    this._transportManager = init.transportManager
-    this._connectionGater = init.connectionGater
-    this._contentRouting = init.contentRouting
-    this._peerRouting = init.peerRouting
-    this._datastore = init.datastore
-    this._connectionProtector = init.connectionProtector
-    this._dht = init.dht
-    this._pubsub = init.pubsub
+    this.components = {}
+
+    for (const [key, value] of Object.entries(init)) {
+      this.components[key] = value
+    }
   }
 
   isStarted (): boolean {
     return this._started
   }
 
-  async beforeStart (): Promise<void> {
+  private async _invokeStartableMethod (methodName: 'beforeStart' | 'start' | 'afterStart' | 'beforeStop' | 'stop' | 'afterStop'): Promise<void> {
     await Promise.all(
-      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
-        if (startable.beforeStart != null) {
-          await startable.beforeStart()
-        }
-      })
+      Object.values(this.components)
+        .filter(obj => isStartable(obj))
+        .map(async (startable: Startable) => {
+          await startable[methodName]?.()
+        })
     )
   }
 
-  async start (): Promise<void> {
-    await Promise.all(
-      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
-        await startable.start()
-      })
-    )
+  async beforeStart (): Promise<void> {
+    await this._invokeStartableMethod('beforeStart')
+  }
 
+  async start (): Promise<void> {
+    await this._invokeStartableMethod('start')
     this._started = true
   }
 
   async afterStart (): Promise<void> {
-    await Promise.all(
-      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
-        if (startable.afterStart != null) {
-          await startable.afterStart()
-        }
-      })
-    )
+    await this._invokeStartableMethod('afterStart')
   }
 
   async beforeStop (): Promise<void> {
-    await Promise.all(
-      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
-        if (startable.beforeStop != null) {
-          await startable.beforeStop()
-        }
-      })
-    )
+    await this._invokeStartableMethod('beforeStop')
   }
 
   async stop (): Promise<void> {
-    await Promise.all(
-      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
-        await startable.stop()
-      })
-    )
-
+    await this._invokeStartableMethod('stop')
     this._started = false
   }
 
   async afterStop (): Promise<void> {
-    await Promise.all(
-      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
-        if (startable.afterStop != null) {
-          await startable.afterStop()
-        }
-      })
-    )
-  }
-
-  get peerId (): PeerId {
-    if (this._peerId == null) {
-      throw new CodeError('peerId not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._peerId
-  }
-
-  set peerId (peerId: PeerId) {
-    this._peerId = peerId
-  }
-
-  get addressManager (): AddressManager {
-    if (this._addressManager == null) {
-      throw new CodeError('addressManager not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._addressManager
-  }
-
-  set addressManager (addressManager: AddressManager) {
-    this._addressManager = addressManager
-  }
-
-  get peerStore (): PeerStore {
-    if (this._peerStore == null) {
-      throw new CodeError('peerStore not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._peerStore
-  }
-
-  set peerStore (peerStore: PeerStore) {
-    this._peerStore = peerStore
-  }
-
-  get upgrader (): Upgrader {
-    if (this._upgrader == null) {
-      throw new CodeError('upgrader not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._upgrader
-  }
-
-  set upgrader (upgrader: Upgrader) {
-    this._upgrader = upgrader
-  }
-
-  get registrar (): Registrar {
-    if (this._registrar == null) {
-      throw new CodeError('registrar not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._registrar
-  }
-
-  set registrar (registrar: Registrar) {
-    this._registrar = registrar
-  }
-
-  get connectionManager (): ConnectionManager {
-    if (this._connectionManager == null) {
-      throw new CodeError('connectionManager not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._connectionManager
-  }
-
-  set connectionManager (connectionManager: ConnectionManager) {
-    this._connectionManager = connectionManager
-  }
-
-  get transportManager (): TransportManager {
-    if (this._transportManager == null) {
-      throw new CodeError('transportManager not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._transportManager
-  }
-
-  set transportManager (transportManager: TransportManager) {
-    this._transportManager = transportManager
-  }
-
-  get connectionGater (): ConnectionGater {
-    if (this._connectionGater == null) {
-      throw new CodeError('connectionGater not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._connectionGater
-  }
-
-  set connectionGater (connectionGater: ConnectionGater) {
-    this._connectionGater = connectionGater
-  }
-
-  get contentRouting (): ContentRouting {
-    if (this._contentRouting == null) {
-      throw new CodeError('contentRouting not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._contentRouting
+    await this._invokeStartableMethod('afterStop')
   }
+}
 
-  set contentRouting (contentRouting: ContentRouting) {
-    this._contentRouting = contentRouting
-  }
+const OPTIONAL_SERVICES = [
+  'metrics',
+  'connectionProtector'
+]
+
+const NON_SERVICE_PROPERTIES = [
+  'components',
+  'isStarted',
+  'beforeStart',
+  'start',
+  'afterStart',
+  'beforeStop',
+  'stop',
+  'afterStop',
+  'then',
+  '_invokeStartableMethod'
+]
+
+export function defaultComponents (init: ComponentsInit = {}): Components {
+  const components = new DefaultComponents(init)
+
+  const proxy = new Proxy(components, {
+    get (target, prop, receiver) {
+      if (typeof prop === 'string' && !NON_SERVICE_PROPERTIES.includes(prop)) {
+        const service = components.components[prop]
+
+        if (service == null && !OPTIONAL_SERVICES.includes(prop)) {
+          throw new CodeError(`${prop} not set`, 'ERR_SERVICE_MISSING')
+        }
 
-  get peerRouting (): PeerRouting {
-    if (this._peerRouting == null) {
-      throw new CodeError('peerRouting not set', 'ERR_SERVICE_MISSING')
-    }
+        return service
+      }
 
-    return this._peerRouting
-  }
+      return Reflect.get(target, prop, receiver)
+    },
 
-  set peerRouting (peerRouting: PeerRouting) {
-    this._peerRouting = peerRouting
-  }
+    set (target, prop, value) {
+      if (typeof prop === 'string') {
+        components.components[prop] = value
+      } else {
+        Reflect.set(target, prop, value)
+      }
 
-  get datastore (): Datastore {
-    if (this._datastore == null) {
-      throw new CodeError('datastore not set', 'ERR_SERVICE_MISSING')
+      return true
     }
+  })
 
-    return this._datastore
-  }
-
-  set datastore (datastore: Datastore) {
-    this._datastore = datastore
-  }
-
-  get connectionProtector (): ConnectionProtector | undefined {
-    return this._connectionProtector
-  }
-
-  set connectionProtector (connectionProtector: ConnectionProtector | undefined) {
-    this._connectionProtector = connectionProtector
-  }
-
-  get metrics (): Metrics | undefined {
-    return this._metrics
-  }
-
-  set metrics (metrics: Metrics | undefined) {
-    this._metrics = metrics
-  }
-
-  get dht (): DualDHT | undefined {
-    return this._dht
-  }
-
-  set dht (dht: DualDHT | undefined) {
-    this._dht = dht
-  }
-
-  get pubsub (): PubSub | undefined {
-    return this._pubsub
-  }
-
-  set pubsub (pubsub: PubSub | undefined) {
-    this._pubsub = pubsub
-  }
+  // @ts-expect-error component keys are proxied
+  return proxy
 }