@libp2p/circuit-relay-v2 1.0.24 → 1.0.25-44791342

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)
@@ -359,6 +336,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       return
     }
 
+    const limit = this.reservationStore.get(dstPeer)?.limit
     const destinationConnection = connections[0]
 
     const destinationStream = await this.stopHop({
@@ -368,7 +346,8 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
         peer: {
           id: connection.remotePeer.toBytes(),
           addrs: []
-        }
+        },
+        limit
       }
     })
 
@@ -378,11 +357,14 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       return
     }
 
-    await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.OK })
+    await hopstr.write({
+      type: HopMessage.Type.STATUS,
+      status: Status.OK,
+      limit
+    })
     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

package/src/server/reservation-store.ts

@@ -2,7 +2,7 @@ import { PeerMap } from '@libp2p/peer-collections'
 import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT, DEFAULT_MAX_RESERVATION_CLEAR_INTERVAL, DEFAULT_MAX_RESERVATION_STORE_SIZE, DEFAULT_MAX_RESERVATION_TTL } from '../constants.js'
 import { type Limit, Status } from '../pb/index.js'
 import type { RelayReservation } from '../index.js'
-import type { RecursivePartial, PeerId, Startable } from '@libp2p/interface'
+import type { PeerId, Startable } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export type ReservationStatus = Status.OK | Status.PERMISSION_DENIED | Status.RESERVATION_REFUSED
@@ -34,8 +34,6 @@ export interface ReservationStoreInit {
   defaultDataLimit?: bigint
 }
 
-export type ReservationStoreOptions = RecursivePartial<ReservationStoreInit>
-
 export class ReservationStore implements Startable {
   public readonly reservations = new PeerMap<RelayReservation>()
   private _started = false
@@ -47,7 +45,7 @@ export class ReservationStore implements Startable {
   private readonly defaultDurationLimit: number
   private readonly defaultDataLimit: bigint
 
-  constructor (options: ReservationStoreOptions = {}) {
+  constructor (options: ReservationStoreInit = {}) {
     this.maxReservations = options.maxReservations ?? DEFAULT_MAX_RESERVATION_STORE_SIZE
     this.reservationClearInterval = options.reservationClearInterval ?? DEFAULT_MAX_RESERVATION_CLEAR_INTERVAL
     this.applyDefaultLimit = options.applyDefaultLimit !== false