@libp2p/circuit-relay-v2 1.0.24-62e32252a → 1.0.24-757fb2674

package/src/transport/discovery.ts

@@ -1,28 +1,24 @@
-import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
-import { PeerQueue } from '@libp2p/utils/peer-queue'
-import { anySignal } from 'any-signal'
-import { raceSignal } from 'race-signal'
+import { TypedEventEmitter } from '@libp2p/interface'
 import {
+  RELAY_RENDEZVOUS_NS,
   RELAY_V2_HOP_CODEC
 } from '../constants.js'
-import type { ComponentLogger, Logger, PeerId, PeerStore, Startable, TopologyFilter } from '@libp2p/interface'
-import type { ConnectionManager, RandomWalk, Registrar, TransportManager } from '@libp2p/interface-internal'
+import { namespaceToCid } from '../utils.js'
+import type { ComponentLogger, Logger, ContentRouting, PeerId, PeerStore, Startable } from '@libp2p/interface'
+import type { ConnectionManager, Registrar, TransportManager } from '@libp2p/interface-internal'
 
 export interface RelayDiscoveryEvents {
   'relay:discover': CustomEvent<PeerId>
 }
 
 export interface RelayDiscoveryComponents {
+  peerId: PeerId
   peerStore: PeerStore
   connectionManager: ConnectionManager
   transportManager: TransportManager
+  contentRouting: ContentRouting
   registrar: Registrar
   logger: ComponentLogger
-  randomWalk: RandomWalk
-}
-
-export interface RelayDiscoveryInit {
-  filter?: TopologyFilter
 }
 
 /**
@@ -30,30 +26,23 @@ export interface RelayDiscoveryInit {
  * peers that support the circuit v2 HOP protocol.
  */
 export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> implements Startable {
+  private readonly peerId: PeerId
   private readonly peerStore: PeerStore
+  private readonly contentRouting: ContentRouting
   private readonly registrar: Registrar
-  private readonly connectionManager: ConnectionManager
-  private readonly randomWalk: RandomWalk
   private started: boolean
-  private running: boolean
   private topologyId?: string
   private readonly log: Logger
-  private discoveryController: AbortController
-  private readonly filter?: TopologyFilter
 
-  constructor (components: RelayDiscoveryComponents, init: RelayDiscoveryInit = {}) {
+  constructor (components: RelayDiscoveryComponents) {
     super()
 
     this.log = components.logger.forComponent('libp2p:circuit-relay:discover-relays')
     this.started = false
-    this.running = false
+    this.peerId = components.peerId
     this.peerStore = components.peerStore
+    this.contentRouting = components.contentRouting
     this.registrar = components.registrar
-    this.connectionManager = components.connectionManager
-    this.randomWalk = components.randomWalk
-    this.filter = init.filter
-    this.discoveryController = new AbortController()
-    setMaxListeners(Infinity, this.discoveryController.signal)
   }
 
   isStarted (): boolean {
@@ -64,9 +53,8 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
     // register a topology listener for when new peers are encountered
     // that support the hop protocol
     this.topologyId = await this.registrar.register(RELAY_V2_HOP_CODEC, {
-      filter: this.filter,
+      notifyOnTransient: true,
       onConnect: (peerId) => {
-        this.log('discovered relay %p', peerId)
         this.safeDispatchEvent('relay:discover', { detail: peerId })
       }
     })
@@ -74,12 +62,18 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
     this.started = true
   }
 
+  afterStart (): void {
+    void this.discover()
+      .catch(err => {
+        this.log.error('error discovering relays', err)
+      })
+  }
+
   stop (): void {
     if (this.topologyId != null) {
       this.registrar.unregister(this.topologyId)
     }
 
-    this.discoveryController?.abort()
     this.started = false
   }
 
@@ -87,113 +81,54 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
    * Try to listen on available hop relay connections.
    * The following order will happen while we do not have enough relays:
    *
-   * 1. Check the metadata store for known relays, try to listen on the ones we are already connected to
+   * 1. Check the metadata store for known relays, try to listen on the ones we are already connected
    * 2. Dial and try to listen on the peers we know that support hop but are not connected
    * 3. Search the network
    */
-  startDiscovery (): void {
-    if (this.running) {
-      return
-    }
-
-    this.log('start discovery')
-    this.running = true
-    this.discoveryController = new AbortController()
-    setMaxListeners(Infinity, this.discoveryController.signal)
-
-    Promise.resolve()
-      .then(async () => {
-        this.log('searching peer store for relays')
-
-        const peers = (await this.peerStore.all({
-          filters: [
-            // filter by a list of peers supporting RELAY_V2_HOP and ones we are not listening on
-            (peer) => {
-              return peer.protocols.includes(RELAY_V2_HOP_CODEC)
-            }
-          ],
-          orders: [
-            () => Math.random() < 0.5 ? 1 : -1
-          ]
-        }))
-
-        for (const peer of peers) {
-          this.log.trace('found relay peer %p in peer store', peer.id)
-          this.safeDispatchEvent('relay:discover', { detail: peer.id })
+  async discover (): Promise<void> {
+    this.log('searching peer store for relays')
+    const peers = (await this.peerStore.all({
+      filters: [
+        // filter by a list of peers supporting RELAY_V2_HOP and ones we are not listening on
+        (peer) => {
+          return peer.protocols.includes(RELAY_V2_HOP_CODEC)
         }
+      ],
+      orders: [
+        () => Math.random() < 0.5 ? 1 : -1
+      ]
+    }))
+
+    for (const peer of peers) {
+      this.log('found relay peer %p in content peer store', peer.id)
+      this.safeDispatchEvent('relay:discover', { detail: peer.id })
+    }
 
-        this.log('found %d relay peers in peer store', peers.length)
-
-        // perform random walk and dial peers - after identify has run, the network
-        // topology will be notified of new relays
-        const queue = new PeerQueue({
-          concurrency: 5
-        })
-
-        this.log('start random walk')
-        for await (const peer of this.randomWalk.walk({ signal: this.discoveryController.signal })) {
-          this.log.trace('found random peer %p', peer.id)
-
-          if (queue.has(peer.id)) {
-            this.log.trace('random peer %p was already in queue', peer.id)
-
-            // skip peers already in the queue
-            continue
-          }
-
-          if (this.connectionManager.getConnections(peer.id)?.length > 0) {
-            this.log.trace('random peer %p was already connected', peer.id)
-
-            // skip peers we are already connected to
-            continue
-          }
-
-          if (!(await this.connectionManager.isDialable(peer.multiaddrs))) {
-            this.log.trace('random peer %p was not dialable', peer.id, peer.multiaddrs.map(ma => ma.toString()))
-
-            // skip peers we can't dial
-            continue
-          }
-
-          this.log.trace('wait for space in queue for %p', peer.id)
+    this.log('found %d relay peers in peer store', peers.length)
 
-          // pause the random walk until there is space in the queue
-          await raceSignal(queue.onSizeLessThan(10), this.discoveryController.signal)
+    try {
+      this.log('searching content routing for relays')
+      const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
 
-          this.log('adding random peer %p to dial queue (length: %d)', peer.id, queue.size)
+      let found = 0
 
-          // dial the peer - this will cause identify to run and our topology to
-          // be notified and we'll attempt to create reservations
-          queue.add(async () => {
-            const signal = anySignal([this.discoveryController.signal, AbortSignal.timeout(5000)])
-            setMaxListeners(Infinity, signal)
+      for await (const provider of this.contentRouting.findProviders(cid)) {
+        if (provider.multiaddrs.length > 0 && !provider.id.equals(this.peerId)) {
+          const peerId = provider.id
 
-            try {
-              await this.connectionManager.openConnection(peer.id, { signal })
-            } finally {
-              signal.clear()
-            }
-          }, {
-            peerId: peer.id,
-            signal: this.discoveryController.signal
+          found++
+          await this.peerStore.merge(peerId, {
+            multiaddrs: provider.multiaddrs
           })
-            .catch(err => {
-              this.log.error('error opening connection to random peer %p', peer.id, err)
-            })
-        }
 
-        await queue.onIdle()
-      })
-      .catch(err => {
-        if (!this.discoveryController.signal.aborted) {
-          this.log.error('failed when finding relays on the network', err)
+          this.log('found relay peer %p in content routing', peerId)
+          this.safeDispatchEvent('relay:discover', { detail: peerId })
         }
-      })
-  }
+      }
 
-  stopDiscovery (): void {
-    this.log('stop discovery')
-    this.running = false
-    this.discoveryController?.abort()
+      this.log('found %d relay peers in content routing', found)
+    } catch (err: any) {
+      this.log.error('failed when finding relays on the network', err)
+    }
   }
 }

package/src/transport/index.ts

@@ -1,16 +1,20 @@
+import { type Transport, type Upgrader, type Libp2pEvents, type ComponentLogger, type ConnectionGater, type ContentRouting, type TypedEventTarget, type PeerId, type PeerStore } from '@libp2p/interface'
+import { type RelayDiscoveryComponents } from './discovery.js'
+import { type RelayStoreInit } from './reservation-store.js'
 import { CircuitRelayTransport } from './transport.js'
-import type { RelayDiscoveryComponents } from './discovery.js'
-import type { RelayStoreInit } from './reservation-store.js'
-import type { Transport, Upgrader, Libp2pEvents, ConnectionGater, TypedEventTarget, PeerId, TopologyFilter } from '@libp2p/interface'
-import type { AddressManager, Registrar } from '@libp2p/interface-internal'
+import type { AddressManager, ConnectionManager, Registrar } from '@libp2p/interface-internal'
 
 export interface CircuitRelayTransportComponents extends RelayDiscoveryComponents {
   peerId: PeerId
+  peerStore: PeerStore
   registrar: Registrar
+  connectionManager: ConnectionManager
   upgrader: Upgrader
   addressManager: AddressManager
+  contentRouting: ContentRouting
   connectionGater: ConnectionGater
   events: TypedEventTarget<Libp2pEvents>
+  logger: ComponentLogger
 }
 
 /**
@@ -18,48 +22,34 @@ export interface CircuitRelayTransportComponents extends RelayDiscoveryComponent
  */
 export interface CircuitRelayTransportInit extends RelayStoreInit {
   /**
-   * The number of peers running diable relays to search for and connect to
-   *
-   * @default 0
+   * The number of peers running diable relays to search for and
+   * connect to. (default: 0)
    */
   discoverRelays?: number
 
-  /**
-   * An optional filter used to prevent duplicate attempts to reserve relay
-   * slots on the same peer
-   */
-  discoveryFilter?: TopologyFilter
-
   /**
    * The maximum number of simultaneous STOP inbound streams that can be open at
-   * once - each inbound relayed connection uses a STOP stream
-   *
-   * @default 300
+   * once - each inbound relayed connection uses a STOP stream (default: 300)
    */
   maxInboundStopStreams?: number
 
   /**
-   * The maximum number of simultaneous STOP outbound streams that can be open
-   * at once. If this transport is used along with the relay server these
-   * settings should be set to the same value
-   *
-   * @default 300
+   * The maximum number of simultaneous STOP outbound streams that can be open at
+   * once. If this transport is used along with the relay server these settings
+   * should be set to the same value (default: 300)
    */
   maxOutboundStopStreams?: number
 
   /**
-   * Incoming STOP requests (e.g. when a remote peer wants to dial us via a
-   * relay) must finish the initial protocol negotiation within this timeout in
-   * ms
-   *
-   * @default 30000
+   * Incoming STOP requests (e.g. when a remote peer wants to dial us via a relay)
+   * must finish the initial protocol negotiation within this timeout in ms
+   * (default: 30000)
    */
   stopTimeout?: number
 
   /**
    * When creating a reservation it must complete within this number of ms
-   *
-   * @default 10000
+   * (default: 10000)
    */
   reservationCompletionTimeout?: number
 }

package/src/transport/reservation-store.ts

@@ -1,17 +1,15 @@
-import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
+import { TypedEventEmitter } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
-import { createBloomFilter } from '@libp2p/utils/filters'
 import { PeerQueue } from '@libp2p/utils/peer-queue'
 import { multiaddr } from '@multiformats/multiaddr'
 import { pbStream } from 'it-protobuf-stream'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
-import { DEFAULT_MAX_RESERVATION_QUEUE_LENGTH, DEFAULT_RESERVATION_COMPLETION_TIMEOUT, DEFAULT_RESERVATION_CONCURRENCY, RELAY_TAG, RELAY_V2_HOP_CODEC } from '../constants.js'
+import { DEFAULT_RESERVATION_CONCURRENCY, RELAY_TAG, RELAY_V2_HOP_CODEC } from '../constants.js'
 import { HopMessage, Status } from '../pb/index.js'
 import { getExpirationMilliseconds } from '../utils.js'
 import type { Reservation } from '../pb/index.js'
 import type { TypedEventTarget, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, PeerId, PeerStore, Startable, Metrics } from '@libp2p/interface'
 import type { ConnectionManager, TransportManager } from '@libp2p/interface-internal'
-import type { Filter } from '@libp2p/utils/filters'
 
 // allow refreshing a relay reservation if it will expire in the next 10 minutes
 const REFRESH_WINDOW = (60 * 1000) * 10
@@ -71,7 +69,6 @@ interface RelayEntry {
 export interface ReservationStoreEvents {
   'relay:not-enough-relays': CustomEvent
   'relay:removed': CustomEvent<PeerId>
-  'relay:created-reservation': CustomEvent<PeerId>
 }
 
 export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents> implements Startable {
@@ -87,7 +84,6 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
   private readonly reservationCompletionTimeout: number
   private started: boolean
   private readonly log: Logger
-  private readonly relayFilter: Filter
 
   constructor (components: RelayStoreComponents, init?: RelayStoreInit) {
     super()
@@ -100,10 +96,9 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     this.events = components.events
     this.reservations = new PeerMap()
     this.maxDiscoveredRelays = init?.discoverRelays ?? 0
-    this.maxReservationQueueLength = init?.maxReservationQueueLength ?? DEFAULT_MAX_RESERVATION_QUEUE_LENGTH
-    this.reservationCompletionTimeout = init?.reservationCompletionTimeout ?? DEFAULT_RESERVATION_COMPLETION_TIMEOUT
+    this.maxReservationQueueLength = init?.maxReservationQueueLength ?? 100
+    this.reservationCompletionTimeout = init?.reservationCompletionTimeout ?? 10000
     this.started = false
-    this.relayFilter = createBloomFilter(100)
 
     // ensure we don't listen on multiple relays simultaneously
     this.reserveQueue = new PeerQueue({
@@ -128,13 +123,6 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     this.started = true
   }
 
-  afterStart (): void {
-    if (this.reservations.size < this.maxDiscoveredRelays) {
-      this.log('not enough relays %d/%d', this.reservations.size, this.maxDiscoveredRelays)
-      this.safeDispatchEvent('relay:not-enough-relays', {})
-    }
-  }
-
   stop (): void {
     this.reserveQueue.clear()
     this.reservations.forEach(({ timeout }) => {
@@ -146,9 +134,9 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
 
   /**
    * If the number of current relays is beneath the configured `maxReservations`
-   * value, and the passed peer id is not our own, and we have a non-relayed
-   * connection to the remote, and the remote peer speaks the hop protocol, try
-   * to reserve a slot on the remote peer
+   * value, and the passed peer id is not our own, and we have a non-relayed connection
+   * to the remote, and the remote peer speaks the hop protocol, try to reserve a slot
+   * on the remote peer
    */
   async addRelay (peerId: PeerId, type: RelayType): Promise<void> {
     if (this.peerId.equals(peerId)) {
@@ -157,25 +145,18 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     }
 
     if (this.reserveQueue.size > this.maxReservationQueueLength) {
-      this.log('not adding potential relay peer %p as the queue is full', peerId)
+      this.log('not adding relay as the queue is full')
       return
     }
 
     if (this.reserveQueue.has(peerId)) {
-      this.log('potential relay peer %p is already in the reservation queue', peerId)
-      return
-    }
-
-    if (this.relayFilter.has(peerId.toBytes())) {
-      this.log('potential relay peer %p has failed previously, not trying again', peerId, new Error('where').stack)
+      this.log('relay peer is already in the reservation queue')
       return
     }
 
-    this.log('try to reserve relay slot with %p', peerId)
+    this.log('add relay %p', peerId)
 
     await this.reserveQueue.add(async () => {
-      const start = Date.now()
-
       try {
         // allow refresh of an existing reservation if it is about to expire
         const existingReservation = this.reservations.get(peerId)
@@ -202,7 +183,6 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
         }
 
         const signal = AbortSignal.timeout(this.reservationCompletionTimeout)
-        setMaxListeners(Infinity, signal)
 
         const connection = await this.connectionManager.openConnection(peerId, {
           signal
@@ -250,12 +230,8 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
 
         // listen on multiaddr that only the circuit transport is listening for
         await this.transportManager.listen([multiaddr(`/p2p/${peerId.toString()}/p2p-circuit`)])
-
-        this.safeDispatchEvent('relay:created-reservation', {
-          detail: peerId
-        })
       } catch (err) {
-        this.log.error('could not reserve slot on %p after %dms', peerId, Date.now() - start, err)
+        this.log.error('could not reserve slot on %p', peerId, err)
 
         // cancel the renewal timeout if it's been set
         const reservation = this.reservations.get(peerId)
@@ -266,9 +242,6 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
 
         // if listening failed, remove the reservation
         this.reservations.delete(peerId)
-
-        // don't try this peer again
-        this.relayFilter.add(peerId.toBytes())
       }
     }, {
       peerId
@@ -283,10 +256,6 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     return this.reservations.get(peerId)?.reservation
   }
 
-  reservationCount (): number {
-    return this.reservations.size
-  }
-
   async #createReservation (connection: Connection, options: AbortOptions): Promise<Reservation> {
     options.signal?.throwIfAborted()
 
@@ -301,12 +270,11 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     try {
       response = await hopstr.read(options)
     } catch (err: any) {
+      this.log.error('error parsing reserve message response from %p because', connection.remotePeer, err)
       stream.abort(err)
       throw err
     } finally {
-      if (stream.status !== 'closed') {
-        await stream.close(options)
-      }
+      await stream.close()
     }
 
     if (response.status === Status.OK && (response.reservation != null)) {

package/src/transport/transport.ts

@@ -1,12 +1,11 @@
-import { CodeError, start, stop } from '@libp2p/interface'
+import { CodeError } from '@libp2p/interface'
 import { transportSymbol, type Transport, type CreateListenerOptions, type Listener, type Upgrader, type AbortOptions, type ComponentLogger, type Logger, type Connection, type Stream, type ConnectionGater, type PeerId, type PeerStore } from '@libp2p/interface'
-import { peerFilter } from '@libp2p/peer-collections'
 import { peerIdFromBytes, peerIdFromString } from '@libp2p/peer-id'
 import { streamToMaConnection } from '@libp2p/utils/stream-to-ma-conn'
 import * as mafmt from '@multiformats/mafmt'
 import { multiaddr } from '@multiformats/multiaddr'
 import { pbStream } from 'it-protobuf-stream'
-import { CIRCUIT_PROTO_CODE, DEFAULT_DISCOVERY_FILTER_ERROR_RATE, DEFAULT_DISCOVERY_FILTER_SIZE, ERR_HOP_REQUEST_FAILED, ERR_RELAYED_DIAL, MAX_CONNECTIONS, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../constants.js'
+import { CIRCUIT_PROTO_CODE, ERR_HOP_REQUEST_FAILED, ERR_RELAYED_DIAL, MAX_CONNECTIONS, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../constants.js'
 import { StopMessage, HopMessage, Status } from '../pb/index.js'
 import { RelayDiscovery } from './discovery.js'
 import { createListener } from './listener.js'
@@ -78,12 +77,8 @@ export class CircuitRelayTransport implements Transport {
     this.maxOutboundStopStreams = init.maxOutboundStopStreams ?? defaults.maxOutboundStopStreams
     this.stopTimeout = init.stopTimeout ?? defaults.stopTimeout
 
-    const discoverRelays = init.discoverRelays ?? 0
-
-    if (discoverRelays > 0) {
-      this.discovery = new RelayDiscovery(components, {
-        filter: init.discoveryFilter ?? peerFilter(DEFAULT_DISCOVERY_FILTER_SIZE, DEFAULT_DISCOVERY_FILTER_ERROR_RATE)
-      })
+    if (init.discoverRelays != null && init.discoverRelays > 0) {
+      this.discovery = new RelayDiscovery(components)
       this.discovery.addEventListener('relay:discover', (evt) => {
         this.reservationStore.addRelay(evt.detail, 'discovered')
           .catch(err => {
@@ -94,12 +89,10 @@ export class CircuitRelayTransport implements Transport {
 
     this.reservationStore = new ReservationStore(components, init)
     this.reservationStore.addEventListener('relay:not-enough-relays', () => {
-      this.discovery?.startDiscovery()
-    })
-    this.reservationStore.addEventListener('relay:created-reservation', () => {
-      if (this.reservationStore.reservationCount() >= discoverRelays) {
-        this.discovery?.stopDiscovery()
-      }
+      this.discovery?.discover()
+        .catch(err => {
+          this.log.error('could not discover relays', err)
+        })
     })
 
     this.started = false
@@ -110,6 +103,8 @@ export class CircuitRelayTransport implements Transport {
   }
 
   async start (): Promise<void> {
+    this.reservationStore.start()
+
     await this.registrar.handle(RELAY_V2_STOP_CODEC, (data) => {
       void this.onStop(data).catch(err => {
         this.log.error('error while handling STOP protocol', err)
@@ -121,13 +116,18 @@ export class CircuitRelayTransport implements Transport {
       runOnTransientConnection: true
     })
 
-    await start(this.discovery, this.reservationStore)
+    await this.discovery?.start()
 
     this.started = true
   }
 
+  afterStart (): void {
+    this.discovery?.afterStart()
+  }
+
   async stop (): Promise<void> {
-    await stop(this.discovery, this.reservationStore)
+    this.discovery?.stop()
+    this.reservationStore.stop()
     await this.registrar.unhandle(RELAY_V2_STOP_CODEC)
 
     this.started = false
@@ -231,9 +231,9 @@ export class CircuitRelayTransport implements Transport {
         logger: this.logger
       })
 
-      this.log('new outbound relayed connection %a', maConn.remoteAddr)
+      this.log('new outbound transient connection %a', maConn.remoteAddr)
       return await this.upgrader.upgradeOutbound(maConn, {
-        transient: status.limit != null
+        transient: true
       })
     } catch (err: any) {
       this.log.error(`Circuit relay dial to destination ${destinationPeer.toString()} via relay ${connection.remotePeer.toString()} failed`, err)
@@ -346,9 +346,9 @@ export class CircuitRelayTransport implements Transport {
       logger: this.logger
     })
 
-    this.log('new inbound relayed connection %a', maConn.remoteAddr)
+    this.log('new inbound transient connection %a', maConn.remoteAddr)
     await this.upgrader.upgradeInbound(maConn, {
-      transient: request.limit != null
+      transient: true
     })
     this.log('%s connection %a upgraded', 'inbound', maConn.remoteAddr)
   }