@libp2p/circuit-relay-v2 1.0.24-169c9d85e → 1.0.24-440c9b360

package/src/pb/index.ts

@@ -4,8 +4,8 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 
-import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
+import { type Codec, CodeError, decodeMessage, type DecodeOptions, encodeMessage, enumeration, message } from 'protons-runtime'
+import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface HopMessage {
@@ -72,7 +72,7 @@ export namespace HopMessage {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
@@ -81,24 +81,36 @@ export namespace HopMessage {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.type = HopMessage.Type.codec().decode(reader)
               break
-            case 2:
-              obj.peer = Peer.codec().decode(reader, reader.uint32())
+            }
+            case 2: {
+              obj.peer = Peer.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.peer
+              })
               break
-            case 3:
-              obj.reservation = Reservation.codec().decode(reader, reader.uint32())
+            }
+            case 3: {
+              obj.reservation = Reservation.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.reservation
+              })
               break
-            case 4:
-              obj.limit = Limit.codec().decode(reader, reader.uint32())
+            }
+            case 4: {
+              obj.limit = Limit.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.limit
+              })
               break
-            case 5:
+            }
+            case 5: {
               obj.status = Status.codec().decode(reader)
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -113,8 +125,8 @@ export namespace HopMessage {
     return encodeMessage(obj, HopMessage.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): HopMessage => {
-    return decodeMessage(buf, HopMessage.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<HopMessage>): HopMessage => {
+    return decodeMessage(buf, HopMessage.codec(), opts)
   }
 }
 
@@ -174,7 +186,7 @@ export namespace StopMessage {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
@@ -183,21 +195,30 @@ export namespace StopMessage {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.type = StopMessage.Type.codec().decode(reader)
               break
-            case 2:
-              obj.peer = Peer.codec().decode(reader, reader.uint32())
+            }
+            case 2: {
+              obj.peer = Peer.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.peer
+              })
               break
-            case 3:
-              obj.limit = Limit.codec().decode(reader, reader.uint32())
+            }
+            case 3: {
+              obj.limit = Limit.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.limit
+              })
               break
-            case 4:
+            }
+            case 4: {
               obj.status = Status.codec().decode(reader)
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -212,8 +233,8 @@ export namespace StopMessage {
     return encodeMessage(obj, StopMessage.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): StopMessage => {
-    return decodeMessage(buf, StopMessage.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<StopMessage>): StopMessage => {
+    return decodeMessage(buf, StopMessage.codec(), opts)
   }
 }
 
@@ -247,9 +268,9 @@ export namespace Peer {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
-          id: new Uint8Array(0),
+          id: uint8ArrayAlloc(0),
           addrs: []
         }
 
@@ -259,15 +280,22 @@ export namespace Peer {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.id = reader.bytes()
               break
-            case 2:
+            }
+            case 2: {
+              if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) {
+                throw new CodeError('decode error - map field "addrs" had too many elements', 'ERR_MAX_LENGTH')
+              }
+
               obj.addrs.push(reader.bytes())
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -282,8 +310,8 @@ export namespace Peer {
     return encodeMessage(obj, Peer.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Peer => {
-    return decodeMessage(buf, Peer.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Peer>): Peer => {
+    return decodeMessage(buf, Peer.codec(), opts)
   }
 }
 
@@ -323,7 +351,7 @@ export namespace Reservation {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           expire: 0n,
           addrs: []
@@ -335,18 +363,26 @@ export namespace Reservation {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.expire = reader.uint64()
               break
-            case 2:
+            }
+            case 2: {
+              if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) {
+                throw new CodeError('decode error - map field "addrs" had too many elements', 'ERR_MAX_LENGTH')
+              }
+
               obj.addrs.push(reader.bytes())
               break
-            case 3:
+            }
+            case 3: {
               obj.voucher = reader.bytes()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -361,8 +397,8 @@ export namespace Reservation {
     return encodeMessage(obj, Reservation.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Reservation => {
-    return decodeMessage(buf, Reservation.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Reservation>): Reservation => {
+    return decodeMessage(buf, Reservation.codec(), opts)
   }
 }
 
@@ -394,7 +430,7 @@ export namespace Limit {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
@@ -403,15 +439,18 @@ export namespace Limit {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.duration = reader.uint32()
               break
-            case 2:
+            }
+            case 2: {
               obj.data = reader.uint64()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -426,8 +465,8 @@ export namespace Limit {
     return encodeMessage(obj, Limit.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Limit => {
-    return decodeMessage(buf, Limit.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Limit>): Limit => {
+    return decodeMessage(buf, Limit.codec(), opts)
   }
 }
 
@@ -494,10 +533,10 @@ export namespace ReservationVoucher {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
-          relay: new Uint8Array(0),
-          peer: new Uint8Array(0),
+          relay: uint8ArrayAlloc(0),
+          peer: uint8ArrayAlloc(0),
           expiration: 0n
         }
 
@@ -507,18 +546,22 @@ export namespace ReservationVoucher {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.relay = reader.bytes()
               break
-            case 2:
+            }
+            case 2: {
               obj.peer = reader.bytes()
               break
-            case 3:
+            }
+            case 3: {
               obj.expiration = reader.uint64()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -533,7 +576,7 @@ export namespace ReservationVoucher {
     return encodeMessage(obj, ReservationVoucher.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): ReservationVoucher => {
-    return decodeMessage(buf, ReservationVoucher.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ReservationVoucher>): ReservationVoucher => {
+    return decodeMessage(buf, ReservationVoucher.codec(), opts)
   }
 }

package/src/server/index.ts

@@ -14,7 +14,6 @@ import {
 } from '../constants.js'
 import { HopMessage, type Reservation, Status, StopMessage } from '../pb/index.js'
 import { createLimitedRelay } from '../utils.js'
-import { AdvertService, type AdvertServiceComponents, type AdvertServiceInit } from './advert-service.js'
 import { ReservationStore, type ReservationStoreInit } from './reservation-store.js'
 import { ReservationVoucherRecord } from './reservation-voucher.js'
 import type { CircuitRelayService, RelayReservation } from '../index.js'
@@ -31,12 +30,6 @@ export interface CircuitRelayServerInit {
    */
   hopTimeout?: number
 
-  /**
-   * If true, advertise this service via libp2p content routing to allow
-   * peers to locate us on the network (default: false)
-   */
-  advertise?: boolean | AdvertServiceInit
-
   /**
    * Configuration of reservations
    */
@@ -70,7 +63,7 @@ export interface StopOptions {
   request: StopMessage
 }
 
-export interface CircuitRelayServerComponents extends AdvertServiceComponents {
+export interface CircuitRelayServerComponents {
   registrar: Registrar
   peerStore: PeerStore
   addressManager: AddressManager
@@ -98,7 +91,6 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
   private readonly connectionManager: ConnectionManager
   private readonly connectionGater: ConnectionGater
   private readonly reservationStore: ReservationStore
-  private readonly advertService: AdvertService | undefined
   private started: boolean
   private readonly hopTimeout: number
   private readonly shutdownController: AbortController
@@ -122,24 +114,13 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
     this.connectionGater = components.connectionGater
     this.started = false
     this.hopTimeout = init?.hopTimeout ?? DEFAULT_HOP_TIMEOUT
-    this.shutdownController = new AbortController()
     this.maxInboundHopStreams = init.maxInboundHopStreams
     this.maxOutboundHopStreams = init.maxOutboundHopStreams
     this.maxOutboundStopStreams = init.maxOutboundStopStreams ?? defaults.maxOutboundStopStreams
+    this.reservationStore = new ReservationStore(init.reservations)
 
+    this.shutdownController = new AbortController()
     setMaxListeners(Infinity, this.shutdownController.signal)
-
-    if (init.advertise != null && init.advertise !== false) {
-      this.advertService = new AdvertService(components, init.advertise === true ? undefined : init.advertise)
-      this.advertService.addEventListener('advert:success', () => {
-        this.safeDispatchEvent('relay:advert:success', {})
-      })
-      this.advertService.addEventListener('advert:error', (evt) => {
-        this.safeDispatchEvent('relay:advert:error', { detail: evt.detail })
-      })
-    }
-
-    this.reservationStore = new ReservationStore(init.reservations)
   }
 
   isStarted (): boolean {
@@ -154,9 +135,6 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       return
     }
 
-    // Advertise service if HOP enabled and advertising enabled
-    this.advertService?.start()
-
     await this.registrar.handle(RELAY_V2_HOP_CODEC, (data) => {
       void this.onHop(data).catch(err => {
         this.log.error(err)
@@ -176,7 +154,6 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
    * Stop Relay service
    */
   async stop (): Promise<void> {
-    this.advertService?.stop()
     this.reservationStore.stop()
     this.shutdownController.abort()
     await this.registrar.unhandle(RELAY_V2_HOP_CODEC)

package/src/transport/discovery.ts

@@ -1,24 +1,28 @@
-import { TypedEventEmitter } from '@libp2p/interface'
+import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
+import { PeerQueue } from '@libp2p/utils/peer-queue'
+import { anySignal } from 'any-signal'
+import { raceSignal } from 'race-signal'
 import {
-  RELAY_RENDEZVOUS_NS,
   RELAY_V2_HOP_CODEC
 } from '../constants.js'
-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'
+import type { ComponentLogger, Logger, PeerId, PeerStore, Startable, TopologyFilter } from '@libp2p/interface'
+import type { ConnectionManager, RandomWalk, 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
 }
 
 /**
@@ -26,23 +30,30 @@ export interface RelayDiscoveryComponents {
  * 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) {
+  constructor (components: RelayDiscoveryComponents, init: RelayDiscoveryInit = {}) {
     super()
 
     this.log = components.logger.forComponent('libp2p:circuit-relay:discover-relays')
     this.started = false
-    this.peerId = components.peerId
+    this.running = false
     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 {
@@ -53,8 +64,9 @@ 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, {
-      notifyOnTransient: true,
+      filter: this.filter,
       onConnect: (peerId) => {
+        this.log('discovered relay %p', peerId)
         this.safeDispatchEvent('relay:discover', { detail: peerId })
       }
     })
@@ -62,18 +74,12 @@ 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
   }
 
@@ -81,54 +87,113 @@ 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
+   * 1. Check the metadata store for known relays, try to listen on the ones we are already connected to
    * 2. Dial and try to listen on the peers we know that support hop but are not connected
    * 3. Search the network
    */
-  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 })
+  startDiscovery (): void {
+    if (this.running) {
+      return
     }
 
-    this.log('found %d relay peers in peer store', peers.length)
+    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 })
+        }
+
+        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
+          }
 
-    try {
-      this.log('searching content routing for relays')
-      const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
+          if (this.connectionManager.getConnections(peer.id)?.length > 0) {
+            this.log.trace('random peer %p was already connected', peer.id)
 
-      let found = 0
+            // skip peers we are already connected to
+            continue
+          }
 
-      for await (const provider of this.contentRouting.findProviders(cid)) {
-        if (provider.multiaddrs.length > 0 && !provider.id.equals(this.peerId)) {
-          const peerId = provider.id
+          if (!(await this.connectionManager.isDialable(peer.multiaddrs))) {
+            this.log.trace('random peer %p was not dialable', peer.id, peer.multiaddrs.map(ma => ma.toString()))
 
-          found++
-          await this.peerStore.merge(peerId, {
-            multiaddrs: provider.multiaddrs
+            // skip peers we can't dial
+            continue
+          }
+
+          this.log.trace('wait for space in queue for %p', peer.id)
+
+          // pause the random walk until there is space in the queue
+          await raceSignal(queue.onSizeLessThan(10), this.discoveryController.signal)
+
+          this.log('adding random peer %p to dial queue (length: %d)', peer.id, queue.size)
+
+          // 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)
+
+            try {
+              await this.connectionManager.openConnection(peer.id, { signal })
+            } finally {
+              signal.clear()
+            }
+          }, {
+            peerId: peer.id,
+            signal: this.discoveryController.signal
           })
+            .catch(err => {
+              this.log.error('error opening connection to random peer %p', peer.id, err)
+            })
+        }
 
-          this.log('found relay peer %p in content routing', peerId)
-          this.safeDispatchEvent('relay:discover', { detail: peerId })
+        await queue.onIdle()
+      })
+      .catch(err => {
+        if (!this.discoveryController.signal.aborted) {
+          this.log.error('failed when finding relays on the network', err)
         }
-      }
+      })
+  }
 
-      this.log('found %d relay peers in content routing', found)
-    } catch (err: any) {
-      this.log.error('failed when finding relays on the network', err)
-    }
+  stopDiscovery (): void {
+    this.log('stop discovery')
+    this.running = false
+    this.discoveryController?.abort()
   }
 }