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

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

package/src/server/advert-service.ts

@@ -0,0 +1,107 @@
+import { TypedEventEmitter } from '@libp2p/interface'
+import pRetry from 'p-retry'
+import {
+  DEFAULT_ADVERT_BOOT_DELAY,
+  ERR_NO_ROUTERS_AVAILABLE,
+  RELAY_RENDEZVOUS_NS
+} from '../constants.js'
+import { namespaceToCid } from '../utils.js'
+import type { ComponentLogger, Logger, ContentRouting, Startable } from '@libp2p/interface'
+
+export interface AdvertServiceInit {
+  /**
+   * How long to wait after startup to begin advertising the service
+   * - if some configured content routers take a while to warm up (for
+   * example, the DHT needs some peers to be able to publish) this
+   * value should be high enough that they will have warmed up
+   */
+  bootDelay?: number
+}
+
+export interface AdvertServiceComponents {
+  contentRouting: ContentRouting
+  logger: ComponentLogger
+}
+
+export interface AdvertServiceEvents {
+  'advert:success': CustomEvent<unknown>
+  'advert:error': CustomEvent<Error>
+}
+
+export class AdvertService extends TypedEventEmitter<AdvertServiceEvents> implements Startable {
+  private readonly contentRouting: ContentRouting
+  private timeout?: any
+  private started: boolean
+  private readonly bootDelay: number
+  private readonly log: Logger
+
+  /**
+   * Creates an instance of Relay
+   */
+  constructor (components: AdvertServiceComponents, init?: AdvertServiceInit) {
+    super()
+
+    this.log = components.logger.forComponent('libp2p:circuit-relay:advert-service')
+    this.contentRouting = components.contentRouting
+    this.bootDelay = init?.bootDelay ?? DEFAULT_ADVERT_BOOT_DELAY
+    this.started = false
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  /**
+   * Start Relay service
+   */
+  start (): void {
+    if (this.started) {
+      return
+    }
+
+    // Advertise service if HOP enabled and advertising enabled
+    this.timeout = setTimeout(() => {
+      this._advertiseService().catch(err => {
+        this.log.error('could not advertise service', err)
+      })
+    }, this.bootDelay)
+
+    this.started = true
+  }
+
+  /**
+   * Stop Relay service
+   */
+  stop (): void {
+    try {
+      clearTimeout(this.timeout)
+    } catch (err) { }
+
+    this.started = false
+  }
+
+  /**
+   * Advertise hop relay service in the network.
+   */
+  async _advertiseService (): Promise<void> {
+    await pRetry(async () => {
+      try {
+        const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
+        await this.contentRouting.provide(cid)
+
+        this.safeDispatchEvent('advert:success', { detail: undefined })
+      } catch (err: any) {
+        this.safeDispatchEvent('advert:error', { detail: err })
+
+        if (err.code === ERR_NO_ROUTERS_AVAILABLE) {
+          this.log.error('a content router, such as a DHT, must be provided in order to advertise the relay service', err)
+          this.stop()
+          return
+        }
+
+        this.log.error('could not advertise service', err)
+        throw err
+      }
+    })
+  }
+}

package/src/server/index.ts

@@ -14,6 +14,7 @@ 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'
@@ -30,6 +31,12 @@ 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
    */
@@ -63,7 +70,7 @@ export interface StopOptions {
   request: StopMessage
 }
 
-export interface CircuitRelayServerComponents {
+export interface CircuitRelayServerComponents extends AdvertServiceComponents {
   registrar: Registrar
   peerStore: PeerStore
   addressManager: AddressManager
@@ -91,6 +98,7 @@ 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
@@ -114,13 +122,24 @@ 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 {
@@ -135,6 +154,9 @@ 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)
@@ -154,6 +176,7 @@ 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)
@@ -336,7 +359,6 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       return
     }
 
-    const limit = this.reservationStore.get(dstPeer)?.limit
     const destinationConnection = connections[0]
 
     const destinationStream = await this.stopHop({
@@ -346,8 +368,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
         peer: {
           id: connection.remotePeer.toBytes(),
           addrs: []
-        },
-        limit
+        }
       }
     })
 
@@ -357,14 +378,11 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       return
     }
 
-    await hopstr.write({
-      type: HopMessage.Type.STATUS,
-      status: Status.OK,
-      limit
-    })
+    await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.OK })
     const sourceStream = stream.unwrap()
 
     this.log('connection from %p to %p established - merging streams', connection.remotePeer, dstPeer)
+    const limit = this.reservationStore.get(dstPeer)?.limit
     // Short circuit the two streams to create the relayed connection
     createLimitedRelay(sourceStream, destinationStream, this.shutdownController.signal, limit, {
       log: this.log