@libp2p/circuit-relay-v2 2.1.4 → 2.1.5-e6b4158c6

package/src/pb/index.ts

@@ -318,7 +318,7 @@ export namespace Peer {
 export interface Reservation {
   expire: bigint
   addrs: Uint8Array[]
-  voucher?: Uint8Array
+  voucher?: Envelope
 }
 
 export namespace Reservation {
@@ -345,7 +345,7 @@ export namespace Reservation {
 
         if (obj.voucher != null) {
           w.uint32(26)
-          w.bytes(obj.voucher)
+          Envelope.codec().encode(obj.voucher, w)
         }
 
         if (opts.lengthDelimited !== false) {
@@ -376,7 +376,9 @@ export namespace Reservation {
               break
             }
             case 3: {
-              obj.voucher = reader.bytes()
+              obj.voucher = Envelope.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.voucher
+              })
               break
             }
             default: {
@@ -580,3 +582,97 @@ export namespace ReservationVoucher {
     return decodeMessage(buf, ReservationVoucher.codec(), opts)
   }
 }
+
+export interface Envelope {
+  publicKey: Uint8Array
+  payloadType: Uint8Array
+  payload?: ReservationVoucher
+  signature: Uint8Array
+}
+
+export namespace Envelope {
+  let _codec: Codec<Envelope>
+
+  export const codec = (): Codec<Envelope> => {
+    if (_codec == null) {
+      _codec = message<Envelope>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if ((obj.publicKey != null && obj.publicKey.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.publicKey)
+        }
+
+        if ((obj.payloadType != null && obj.payloadType.byteLength > 0)) {
+          w.uint32(18)
+          w.bytes(obj.payloadType)
+        }
+
+        if (obj.payload != null) {
+          w.uint32(26)
+          ReservationVoucher.codec().encode(obj.payload, w)
+        }
+
+        if ((obj.signature != null && obj.signature.byteLength > 0)) {
+          w.uint32(42)
+          w.bytes(obj.signature)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length, opts = {}) => {
+        const obj: any = {
+          publicKey: uint8ArrayAlloc(0),
+          payloadType: uint8ArrayAlloc(0),
+          signature: uint8ArrayAlloc(0)
+        }
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              obj.publicKey = reader.bytes()
+              break
+            }
+            case 2: {
+              obj.payloadType = reader.bytes()
+              break
+            }
+            case 3: {
+              obj.payload = ReservationVoucher.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.payload
+              })
+              break
+            }
+            case 5: {
+              obj.signature = reader.bytes()
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
+  }
+
+  export const encode = (obj: Partial<Envelope>): Uint8Array => {
+    return encodeMessage(obj, Envelope.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Envelope>): Envelope => {
+    return decodeMessage(buf, Envelope.codec(), opts)
+  }
+}

package/src/server/index.ts

@@ -1,3 +1,4 @@
+import { publicKeyToProtobuf } from '@libp2p/crypto/keys'
 import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { peerIdFromMultihash } from '@libp2p/peer-id'
 import { RecordEnvelope } from '@libp2p/peer-record'
@@ -156,8 +157,6 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       runOnLimitedConnection: true
     })
 
-    this.reservationStore.start()
-
     this.started = true
   }
 
@@ -165,7 +164,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
    * Stop Relay service
    */
   async stop (): Promise<void> {
-    this.reservationStore.stop()
+    this.reservationStore.clear()
     this.shutdownController.abort()
     await this.registrar.unhandle(RELAY_V2_HOP_CODEC)
 
@@ -290,16 +289,25 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       addrs.push(relayAddr.bytes)
     }
 
-    const voucher = await RecordEnvelope.seal(new ReservationVoucherRecord({
+    const envelope = await RecordEnvelope.seal(new ReservationVoucherRecord({
       peer: remotePeer,
       relay: this.peerId,
-      expiration: Number(expire)
+      expiration: expire
     }), this.privateKey)
 
     return {
       addrs,
       expire,
-      voucher: voucher.marshal()
+      voucher: {
+        publicKey: publicKeyToProtobuf(envelope.publicKey),
+        payloadType: envelope.payloadType,
+        payload: {
+          peer: remotePeer.toMultihash().bytes,
+          relay: this.peerId.toMultihash().bytes,
+          expiration: expire
+        },
+        signature: envelope.signature
+      }
     }
   }
 
@@ -330,7 +338,9 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       return
     }
 
-    if (!this.reservationStore.hasReservation(dstPeer)) {
+    const reservation = this.reservationStore.get(dstPeer)
+
+    if (reservation == null) {
       this.log.error('hop connect denied for destination peer %p not having a reservation for %p with status %s', dstPeer, connection.remotePeer, Status.NO_RESERVATION)
       await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION }, options)
       return
@@ -350,7 +360,6 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       return
     }
 
-    const limit = this.reservationStore.get(dstPeer)?.limit
     const destinationConnection = connections[0]
 
     const destinationStream = await this.stopHop({
@@ -361,7 +370,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
           id: connection.remotePeer.toMultihash().bytes,
           addrs: []
         },
-        limit
+        limit: reservation?.limit
       }
     }, options)
 
@@ -374,13 +383,14 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
     await hopstr.write({
       type: HopMessage.Type.STATUS,
       status: Status.OK,
-      limit
+      limit: reservation?.limit
     }, options)
     const sourceStream = stream.unwrap()
 
     this.log('connection from %p to %p established - merging streams', connection.remotePeer, dstPeer)
+
     // Short circuit the two streams to create the relayed connection
-    createLimitedRelay(sourceStream, destinationStream, this.shutdownController.signal, limit, {
+    createLimitedRelay(sourceStream, destinationStream, this.shutdownController.signal, reservation, {
       log: this.log
     })
   }

package/src/server/reservation-store.ts

@@ -1,14 +1,16 @@
 import { trackedPeerMap } 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 { retimeableSignal } from 'retimeable-signal'
+import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT, 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 { Metrics, PeerId, Startable } from '@libp2p/interface'
+import type { ComponentLogger, Logger, Metrics, PeerId } from '@libp2p/interface'
 import type { PeerMap } from '@libp2p/peer-collections'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export type ReservationStatus = Status.OK | Status.PERMISSION_DENIED | Status.RESERVATION_REFUSED
 
 export interface ReservationStoreComponents {
+  logger: ComponentLogger
   metrics?: Metrics
 }
 
@@ -52,20 +54,18 @@ export interface ReservationStoreInit {
   defaultDataLimit?: bigint
 }
 
-export class ReservationStore implements Startable {
+export class ReservationStore {
   public readonly reservations: PeerMap<RelayReservation>
-  private _started = false
-  private interval: any
   private readonly maxReservations: number
-  private readonly reservationClearInterval: number
   private readonly applyDefaultLimit: boolean
   private readonly reservationTtl: number
   private readonly defaultDurationLimit: number
   private readonly defaultDataLimit: bigint
+  private readonly log: Logger
 
   constructor (components: ReservationStoreComponents, init: ReservationStoreInit = {}) {
+    this.log = components.logger.forComponent('libp2p:circuit-relay:server:reservation-store')
     this.maxReservations = init.maxReservations ?? DEFAULT_MAX_RESERVATION_STORE_SIZE
-    this.reservationClearInterval = init.reservationClearInterval ?? DEFAULT_MAX_RESERVATION_CLEAR_INTERVAL
     this.applyDefaultLimit = init.applyDefaultLimit !== false
     this.reservationTtl = init.reservationTtl ?? DEFAULT_MAX_RESERVATION_TTL
     this.defaultDurationLimit = init.defaultDurationLimit ?? DEFAULT_DURATION_LIMIT
@@ -77,59 +77,55 @@ export class ReservationStore implements Startable {
     })
   }
 
-  isStarted (): boolean {
-    return this._started
-  }
-
-  start (): void {
-    if (this._started) {
-      return
-    }
-    this._started = true
-    this.interval = setInterval(
-      () => {
-        const now = (new Date()).getTime()
-        this.reservations.forEach((r, k) => {
-          if (r.expire.getTime() < now) {
-            this.reservations.delete(k)
-          }
-        })
-      },
-      this.reservationClearInterval
-    )
-  }
-
-  stop (): void {
-    clearInterval(this.interval)
-  }
-
   reserve (peer: PeerId, addr: Multiaddr, limit?: Limit): { status: ReservationStatus, expire?: number } {
-    if (this.reservations.size >= this.maxReservations && !this.reservations.has(peer)) {
+    let reservation = this.reservations.get(peer)
+
+    if (this.reservations.size >= this.maxReservations && reservation == null) {
       return { status: Status.RESERVATION_REFUSED }
     }
 
-    const expire = new Date(Date.now() + this.reservationTtl)
+    const expiry = new Date(Date.now() + this.reservationTtl)
     let checkedLimit: Limit | undefined
 
     if (this.applyDefaultLimit) {
-      checkedLimit = limit ?? { data: this.defaultDataLimit, duration: this.defaultDurationLimit }
+      checkedLimit = limit ?? {
+        data: this.defaultDataLimit,
+        duration: this.defaultDurationLimit
+      }
     }
 
-    this.reservations.set(peer, { addr, expire, limit: checkedLimit })
+    if (reservation != null) {
+      this.log('refreshing reservation for client %p', peer)
+      reservation.signal.reset(this.reservationTtl)
+    } else {
+      this.log('creating new reservation for client %p', peer)
+      reservation = {
+        addr,
+        expiry,
+        limit: checkedLimit,
+        signal: retimeableSignal(this.reservationTtl)
+      }
+    }
+
+    this.reservations.set(peer, reservation)
+
+    reservation.signal.addEventListener('abort', () => {
+      this.reservations.delete(peer)
+    })
 
     // return expiry time in seconds
-    return { status: Status.OK, expire: Math.round(expire.getTime() / 1000) }
+    return { status: Status.OK, expire: Math.round(expiry.getTime() / 1000) }
   }
 
   removeReservation (peer: PeerId): void {
     this.reservations.delete(peer)
   }
 
-  hasReservation (dst: PeerId): boolean {
-    return this.reservations.has(dst)
-  }
-
   get (peer: PeerId): RelayReservation | undefined {
     return this.reservations.get(peer)
   }
+
+  clear (): void {
+    this.reservations.clear()
+  }
 }

package/src/server/reservation-voucher.ts

@@ -4,7 +4,7 @@ import type { PeerId, Record } from '@libp2p/interface'
 export interface ReservationVoucherOptions {
   relay: PeerId
   peer: PeerId
-  expiration: number
+  expiration: bigint
 }
 
 export class ReservationVoucherRecord implements Record {
@@ -13,7 +13,7 @@ export class ReservationVoucherRecord implements Record {
 
   private readonly relay: PeerId
   private readonly peer: PeerId
-  private readonly expiration: number
+  private readonly expiration: bigint
 
   constructor ({ relay, peer, expiration }: ReservationVoucherOptions) {
     this.relay = relay

package/src/transport/reservation-store.ts

@@ -227,12 +227,23 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
         const existingReservation = this.reservations.get(peerId)
 
         if (existingReservation != null) {
-          if (this.connectionManager.getConnections(peerId).map(conn => conn.id).includes(existingReservation.connection) && getExpirationMilliseconds(existingReservation.reservation.expire) > REFRESH_WINDOW) {
+          const connections = this.connectionManager.getConnections(peerId)
+          let connected = false
+
+          if (connections.length === 0) {
+            this.log('already have relay reservation with %p but we are no longer connected', peerId)
+          }
+
+          if (connections.map(conn => conn.id).includes(existingReservation.connection)) {
+            this.log('already have relay reservation with %p and the original connection is still open', peerId)
+            connected = true
+          }
+
+          if (connected && getExpirationMilliseconds(existingReservation.reservation.expire) > REFRESH_WINDOW) {
             this.log('already have relay reservation with %p but we are still connected and it does not expire soon', peerId)
             return
           }
 
-          this.log('already have relay reservation with %p but the original connection is no longer open', peerId)
           await this.#removeReservation(peerId, existingReservation)
         }
 
@@ -263,18 +274,33 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
           signal
         })
 
-        this.log('created reservation on relay peer %p', peerId)
-
         const expiration = getExpirationMilliseconds(reservation.expire)
 
+        this.log('created reservation on relay peer %p, expiry date is %s', peerId, new Date(Date.now() + expiration).toString())
+
         // sets a lower bound on the timeout, and also don't let it go over
         // 2^31 - 1 (setTimeout will only accept signed 32 bit integers)
         const timeoutDuration = Math.min(Math.max(expiration - REFRESH_TIMEOUT, REFRESH_TIMEOUT_MIN), Math.pow(2, 31) - 1)
 
         const timeout = setTimeout(() => {
-          this.addRelay(peerId, type).catch(err => {
-            this.log.error('could not refresh reservation to relay %p', peerId, err)
-          })
+          this.log('refresh reservation to relay %p', peerId)
+
+          this.addRelay(peerId, type)
+            .catch(async err => {
+              this.log.error('could not refresh reservation to relay %p - %e', peerId, err)
+
+              const reservation = this.reservations.get(peerId)
+
+              if (reservation == null) {
+                this.log.error('did not have reservation after refreshing reservation failed %p', peerId)
+                return
+              }
+
+              await this.#removeReservation(peerId, reservation)
+            })
+            .catch(err => {
+              this.log.error('could not remove expired reservation to relay %p - %e', peerId, err)
+            })
         }, timeoutDuration)
 
         // we've managed to create a reservation successfully
@@ -300,7 +326,7 @@ 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`)])
+        await this.transportManager.listen([multiaddr(`/p2p/${peerId.toString()}/p2p-circuit/p2p/${this.peerId.toString()}`)])
 
         this.safeDispatchEvent('relay:created-reservation', {
           detail: peerId
@@ -308,18 +334,19 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
       } catch (err) {
         this.log.error('could not reserve slot on %p after %dms', peerId, Date.now() - start, err)
 
+        // don't try this peer again
+        this.relayFilter.add(peerId.toMultihash().bytes)
+
         // cancel the renewal timeout if it's been set
         const reservation = this.reservations.get(peerId)
 
+        // if listening failed, remove the reservation
         if (reservation != null) {
-          clearTimeout(reservation.timeout)
+          this.#removeReservation(peerId, reservation)
+            .catch(err => {
+              this.log.error('could not remove reservation on %p after reserving slot failed - %e', peerId, err)
+            })
         }
-
-        // if listening failed, remove the reservation
-        this.reservations.delete(peerId)
-
-        // don't try this peer again
-        this.relayFilter.add(peerId.toMultihash().bytes)
       }
     }, {
       peerId
@@ -406,6 +433,11 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
    * Remove listen relay
    */
   async #removeReservation (peerId: PeerId, reservation: RelayEntry): Promise<void> {
+    if (!this.reservations.has(peerId)) {
+      this.log('not removing relay reservation with %p from local store as we do not have a reservation with this peer', peerId)
+      return
+    }
+
     this.log('removing relay reservation with %p from local store', peerId)
     clearTimeout(reservation.timeout)
     this.reservations.delete(peerId)

package/src/transport/transport.ts

@@ -2,14 +2,14 @@ import { DialError, InvalidMessageError, serviceCapabilities, serviceDependencie
 import { peerFilter } from '@libp2p/peer-collections'
 import { peerIdFromMultihash, 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 { Circuit } from '@multiformats/multiaddr-matcher'
 import { pbStream } from 'it-protobuf-stream'
 import * as Digest from 'multiformats/hashes/digest'
 import { CustomProgressEvent } from 'progress-events'
 import { CIRCUIT_PROTO_CODE, DEFAULT_DISCOVERY_FILTER_ERROR_RATE, DEFAULT_DISCOVERY_FILTER_SIZE, MAX_CONNECTIONS, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../constants.js'
 import { StopMessage, HopMessage, Status } from '../pb/index.js'
-import { LimitTracker } from '../utils.js'
+import { CircuitListen, LimitTracker } from '../utils.js'
 import { RelayDiscovery } from './discovery.js'
 import { createListener } from './listener.js'
 import { ReservationStore } from './reservation-store.js'
@@ -184,9 +184,9 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
     const destinationId = destinationAddr.getPeerId()
 
     if (relayId == null || destinationId == null) {
-      const errMsg = `Circuit relay dial to ${ma.toString()} failed as address did not have peer ids`
-      this.log.error(errMsg)
-      throw new DialError(errMsg)
+      const errMsg = `ircuit relay dial to ${ma.toString()} failed as address did not have both relay and destination PeerIDs`
+      this.log.error(`c${errMsg}`)
+      throw new DialError(`C${errMsg}`)
     }
 
     const relayPeer = peerIdFromString(relayId)
@@ -281,7 +281,7 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
         onProgress
       })
     } catch (err: any) {
-      this.log.error(`Circuit relay dial to destination ${destinationPeer.toString()} via relay ${connection.remotePeer.toString()} failed`, err)
+      this.log.error(`circuit relay dial to destination ${destinationPeer.toString()} via relay ${connection.remotePeer.toString()} failed`, err)
       disconnectOnFailure && await connection.close()
       throw err
     }
@@ -305,7 +305,7 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
     multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
 
     return multiaddrs.filter((ma) => {
-      return mafmt.Circuit.matches(ma)
+      return CircuitListen.exactMatch(ma)
     })
   }
 
@@ -313,7 +313,11 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
    * Filter check for all Multiaddrs that this transport can dial
    */
   dialFilter (multiaddrs: Multiaddr[]): Multiaddr[] {
-    return this.listenFilter(multiaddrs)
+    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
+
+    return multiaddrs.filter((ma) => {
+      return Circuit.exactMatch(ma)
+    })
   }
 
   /**

package/src/utils.ts

@@ -1,7 +1,10 @@
+import { P2P } from '@multiformats/multiaddr-matcher'
+import { fmt, peerId, literal, optional, and } from '@multiformats/multiaddr-matcher/utils'
 import { anySignal } from 'any-signal'
 import { CID } from 'multiformats/cid'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { DurationLimitError, TransferLimitError } from './errors.js'
+import type { RelayReservation } from './index.js'
 import type { Limit } from './pb/index.js'
 import type { ConnectionLimits, LoggerOptions, Stream } from '@libp2p/interface'
 import type { Source } from 'it-stream-types'
@@ -34,16 +37,18 @@ async function * countStreamBytes (source: Source<Uint8Array | Uint8ArrayList>,
   }
 }
 
-export function createLimitedRelay (src: Stream, dst: Stream, abortSignal: AbortSignal, limit: Limit | undefined, options: LoggerOptions): void {
+export function createLimitedRelay (src: Stream, dst: Stream, abortSignal: AbortSignal, reservation: RelayReservation, options: LoggerOptions): void {
   function abortStreams (err: Error): void {
     src.abort(err)
     dst.abort(err)
   }
 
-  const signals = [abortSignal]
+  // combine shutdown signal and reservation expiry signal
+  const signals = [abortSignal, reservation.signal]
 
-  if (limit?.duration != null) {
-    signals.push(AbortSignal.timeout(limit.duration))
+  if (reservation.limit?.duration != null) {
+    options.log('limiting relayed connection duration to %dms', reservation.limit.duration)
+    signals.push(AbortSignal.timeout(reservation.limit.duration))
   }
 
   const signal = anySignal(signals)
@@ -53,15 +58,16 @@ export function createLimitedRelay (src: Stream, dst: Stream, abortSignal: Abort
 
   let dataLimit: { remaining: bigint } | undefined
 
-  if (limit?.data != null) {
+  if (reservation.limit?.data != null) {
     dataLimit = {
-      remaining: limit.data
+      remaining: reservation.limit.data
     }
   }
 
   queueMicrotask(() => {
     const onAbort = (): void => {
-      dst.abort(new DurationLimitError(`duration limit of ${limit?.duration} ms exceeded`))
+      options.log('relayed connection reached time limit')
+      dst.abort(new DurationLimitError(`duration limit of ${reservation.limit?.duration} ms exceeded`))
     }
 
     signal.addEventListener('abort', onAbort, { once: true })
@@ -83,7 +89,8 @@ export function createLimitedRelay (src: Stream, dst: Stream, abortSignal: Abort
 
   queueMicrotask(() => {
     const onAbort = (): void => {
-      src.abort(new DurationLimitError(`duration limit of ${limit?.duration} ms exceeded`))
+      options.log('relayed connection reached time limit')
+      src.abort(new DurationLimitError(`duration limit of ${reservation.limit?.duration} ms exceeded`))
     }
 
     signal.addEventListener('abort', onAbort, { once: true })
@@ -185,3 +192,9 @@ export class LimitTracker {
     return output
   }
 }
+
+/**
+ * A custom matcher that makes the `/p2p/peer-id` part of circuit relay
+ * addresses optional
+ */
+export const CircuitListen = fmt(and(P2P.matchers[0], literal('p2p-circuit'), optional(peerId())))

package/dist/typedoc-urls.json

@@ -1,23 +0,0 @@
-{
-  "codec": "https://libp2p.github.io/js-libp2p/functions/_libp2p_circuit_relay_v2.Limit.codec.html",
-  "decode": "https://libp2p.github.io/js-libp2p/functions/_libp2p_circuit_relay_v2.Limit.decode.html",
-  "encode": "https://libp2p.github.io/js-libp2p/functions/_libp2p_circuit_relay_v2.Limit.encode.html",
-  "CircuitRelayServerComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayServerComponents.html",
-  "CircuitRelayServerInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayServerInit.html",
-  "CircuitRelayService": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayService.html",
-  ".:CircuitRelayService": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayService.html",
-  "CircuitRelayServiceEvents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayServiceEvents.html",
-  ".:CircuitRelayServiceEvents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayServiceEvents.html",
-  "CircuitRelayTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayTransportComponents.html",
-  "CircuitRelayTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayTransportInit.html",
-  "Limit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.Limit-1.html",
-  "RelayDiscoveryComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.RelayDiscoveryComponents.html",
-  "RelayReservation": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.RelayReservation.html",
-  ".:RelayReservation": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.RelayReservation.html",
-  "ServerReservationStoreInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.ServerReservationStoreInit.html",
-  "TransportReservationStoreInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.TransportReservationStoreInit.html",
-  "RELAY_V2_HOP_CODEC": "https://libp2p.github.io/js-libp2p/variables/_libp2p_circuit_relay_v2.RELAY_V2_HOP_CODEC.html",
-  "RELAY_V2_STOP_CODEC": "https://libp2p.github.io/js-libp2p/variables/_libp2p_circuit_relay_v2.RELAY_V2_STOP_CODEC.html",
-  "circuitRelayServer": "https://libp2p.github.io/js-libp2p/functions/_libp2p_circuit_relay_v2.circuitRelayServer.html",
-  "circuitRelayTransport": "https://libp2p.github.io/js-libp2p/functions/_libp2p_circuit_relay_v2.circuitRelayTransport.html"
-}