@libp2p/circuit-relay-v2 2.1.4 → 2.1.5-3bc9769b8

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/discovery.ts

@@ -1,11 +1,11 @@
 import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { PeerQueue } from '@libp2p/utils/peer-queue'
 import { anySignal } from 'any-signal'
-import { raceSignal } from 'race-signal'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import {
   RELAY_V2_HOP_CODEC
 } from '../constants.js'
-import type { ComponentLogger, Logger, PeerId, PeerStore, Startable, TopologyFilter } from '@libp2p/interface'
+import type { ComponentLogger, Logger, Peer, PeerId, PeerStore, Startable, TopologyFilter } from '@libp2p/interface'
 import type { ConnectionManager, RandomWalk, Registrar, TransportManager } from '@libp2p/interface-internal'
 
 export interface RelayDiscoveryEvents {
@@ -40,6 +40,7 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
   private readonly log: Logger
   private discoveryController: AbortController
   private readonly filter?: TopologyFilter
+  private queue?: PeerQueue
 
   constructor (components: RelayDiscoveryComponents, init: RelayDiscoveryInit = {}) {
     super()
@@ -66,7 +67,7 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
     this.topologyId = await this.registrar.register(RELAY_V2_HOP_CODEC, {
       filter: this.filter,
       onConnect: (peerId) => {
-        this.log.trace('discovered relay %p', peerId)
+        this.log.trace('discovered relay %p queue (length: %d, active %d)', peerId, this.queue?.size, this.queue?.running)
         this.safeDispatchEvent('relay:discover', { detail: peerId })
       }
     })
@@ -113,7 +114,23 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
             }
           ],
           orders: [
-            () => Math.random() < 0.5 ? 1 : -1
+            // randomise
+            () => Math.random() < 0.5 ? 1 : -1,
+            // prefer peers we've connected to in the past
+            (a, b) => {
+              const lastDialA = getLastDial(a)
+              const lastDialB = getLastDial(b)
+
+              if (lastDialA > lastDialB) {
+                return -1
+              }
+
+              if (lastDialB > lastDialA) {
+                return 1
+              }
+
+              return 0
+            }
           ]
         }))
 
@@ -126,11 +143,12 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
 
         // perform random walk and dial peers - after identify has run, the network
         // topology will be notified of new relays
-        const queue = new PeerQueue({
+        const queue = this.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)
 
@@ -155,12 +173,16 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
             continue
           }
 
-          this.log.trace('wait for space in queue for %p', peer.id)
+          if (queue.queued > 10) {
+            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)
+            // pause the random walk until there is space in the queue
+            await queue.onSizeLessThan(10, {
+              signal: this.discoveryController.signal
+            })
+          }
 
-          this.log('adding random peer %p to dial queue (length: %d)', peer.id, queue.size)
+          this.log('adding random peer %p to dial queue (length: %d, active %d)', peer.id, queue.size, queue.running)
 
           // dial the peer - this will cause identify to run and our topology to
           // be notified and we'll attempt to create reservations
@@ -182,6 +204,8 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
             })
         }
 
+        this.log('stop random walk')
+
         await queue.onIdle()
       })
       .catch(err => {
@@ -197,3 +221,17 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
     this.discoveryController?.abort()
   }
 }
+
+/**
+ * Returns the timestamp of the last time we connected to this peer, if we've
+ * not connected to them before return 0
+ */
+function getLastDial (peer: Peer): number {
+  const lastDial = peer.metadata.get('last-dial-success')
+
+  if (lastDial == null) {
+    return 0
+  }
+
+  return new Date(uint8ArrayToString(lastDial)).getTime()
+}

package/src/transport/index.ts

@@ -17,13 +17,6 @@ export interface CircuitRelayTransportComponents extends RelayDiscoveryComponent
  * RelayConfig configures the circuit v2 relay transport.
  */
 export interface CircuitRelayTransportInit extends ReservationStoreInit {
-  /**
-   * 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

package/src/transport/listener.ts

@@ -1,8 +1,10 @@
-import { ListenError, TypedEventEmitter } from '@libp2p/interface'
-import { PeerMap } from '@libp2p/peer-collections'
+import { ListenError, TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { multiaddr } from '@multiformats/multiaddr'
-import type { ReservationStore } from './reservation-store.js'
-import type { ComponentLogger, Logger, PeerId, Listener, ListenerEvents } from '@libp2p/interface'
+import { DEFAULT_RESERVATION_COMPLETION_TIMEOUT } from '../constants.js'
+import { CircuitListen, CircuitSearch } from '../utils.js'
+import type { RelayDiscovery } from './discovery.js'
+import type { RelayReservation, ReservationStore } from './reservation-store.js'
+import type { ComponentLogger, Logger, Listener, ListenerEvents, PeerId } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -12,79 +14,117 @@ export interface CircuitRelayTransportListenerComponents {
   logger: ComponentLogger
 }
 
+export interface CircuitRelayTransportListenerInit {
+  listenTimeout?: number
+}
+
 class CircuitRelayTransportListener extends TypedEventEmitter<ListenerEvents> implements Listener {
   private readonly connectionManager: ConnectionManager
   private readonly reservationStore: ReservationStore
-  private readonly listeningAddrs: PeerMap<Multiaddr[]>
+  private readonly discovery?: RelayDiscovery
+  private listeningAddrs: Multiaddr[]
   private readonly log: Logger
+  private readonly listenTimeout: number
+  private reservationId?: string
+  private relay?: PeerId
 
-  constructor (components: CircuitRelayTransportListenerComponents) {
+  constructor (components: CircuitRelayTransportListenerComponents, init: CircuitRelayTransportListenerInit = {}) {
     super()
 
     this.log = components.logger.forComponent('libp2p:circuit-relay:transport:listener')
     this.connectionManager = components.connectionManager
     this.reservationStore = components.relayStore
-    this.listeningAddrs = new PeerMap()
+    this.listeningAddrs = []
+    this.listenTimeout = init.listenTimeout ?? DEFAULT_RESERVATION_COMPLETION_TIMEOUT
 
     // remove listening addrs when a relay is removed
     this.reservationStore.addEventListener('relay:removed', this._onRemoveRelayPeer)
+    this.reservationStore.addEventListener('relay:created-reservation', this._onAddRelayPeer)
   }
 
-  _onRemoveRelayPeer = (evt: CustomEvent<PeerId>): void => {
-    const had = this.listeningAddrs.has(evt.detail)
-
-    this.log('relay peer removed %p - had reservation', evt.detail, had)
+  _onRemoveRelayPeer = (evt: CustomEvent<RelayReservation>): void => {
+    this.log('relay removed %p our relay %p', evt.detail.relay, this.relay, this.relay?.equals(evt.detail.relay))
 
-    if (!had) {
+    if (this.relay?.equals(evt.detail.relay) !== true) {
       return
     }
 
-    this.listeningAddrs.delete(evt.detail)
+    this.log('relay peer removed %p', evt.detail.relay)
+
+    this.listeningAddrs = []
 
     // announce listen addresses change
     this.safeDispatchEvent('listening')
   }
 
-  async listen (addr: Multiaddr): Promise<void> {
-    this.log('listen on %a', addr)
-
-    // remove the circuit part to get the peer id of the relay
-    const relayAddr = addr.decapsulate('/p2p-circuit')
-    const relayConn = await this.connectionManager.openConnection(relayAddr)
+  _onAddRelayPeer = (evt: CustomEvent<RelayReservation>): void => {
+    const {
+      relay, details
+    } = evt.detail
 
-    if (!this.reservationStore.hasReservation(relayConn.remotePeer)) {
-      this.log('making reservation on peer %p', relayConn.remotePeer)
-      // addRelay calls transportManager.listen which calls this listen method
-      await this.reservationStore.addRelay(relayConn.remotePeer, 'configured')
+    if (details.type === 'configured') {
       return
     }
 
-    const reservation = this.reservationStore.getReservation(relayConn.remotePeer)
-
-    if (reservation == null) {
-      throw new ListenError('Did not have reservation after making reservation')
-    }
-
-    if (this.listeningAddrs.has(relayConn.remotePeer)) {
-      this.log('already listening on relay %p', relayConn.remotePeer)
+    if (details.id !== this.reservationId) {
       return
     }
 
+    this.log('relay peer added %p', relay)
+
+    this.relay = relay
+
     // add all addresses from the relay reservation
-    this.listeningAddrs.set(relayConn.remotePeer, reservation.addrs
+    this.listeningAddrs = details.reservation.addrs
       .map(buf => multiaddr(buf).encapsulate('/p2p-circuit'))
-    )
 
+    // announce listen addresses change
     this.safeDispatchEvent('listening')
   }
 
+  async listen (addr: Multiaddr): Promise<void> {
+    this.log('listen on %a', addr)
+
+    if (CircuitSearch.exactMatch(addr)) {
+      // start relay discovery
+      this.reservationId = this.reservationStore.reserveRelay()
+    } else if (CircuitListen.exactMatch(addr)) {
+      const signal = AbortSignal.timeout(this.listenTimeout)
+      setMaxListeners(Infinity, signal)
+
+      // try to make a reservation on one particular relay
+      // remove the circuit part to get the peer id of the relay
+      const relayAddr = addr.decapsulate('/p2p-circuit')
+      const relayConn = await this.connectionManager.openConnection(relayAddr, {
+        signal
+      })
+
+      if (!this.reservationStore.hasReservation(relayConn.remotePeer)) {
+        this.log('making reservation on peer %p', relayConn.remotePeer)
+        const reservation = await this.reservationStore.addRelay(relayConn.remotePeer, 'configured')
+        this.log('made reservation on peer %p', relayConn.remotePeer)
+
+        this.relay = reservation.relay
+
+        // add all addresses from the relay reservation
+        this.listeningAddrs = reservation.details.reservation.addrs
+          .map(buf => multiaddr(buf).encapsulate('/p2p-circuit'))
+
+        // if that succeeded announce listen addresses change
+        this.safeDispatchEvent('listening')
+      }
+    } else {
+      throw new ListenError(`Could not listen on p2p-circuit address "${addr}"`)
+    }
+  }
+
   getAddrs (): Multiaddr[] {
     return [...this.listeningAddrs.values()].flat()
   }
 
   async close (): Promise<void> {
-    await this.reservationStore.cancelReservations()
-    this.listeningAddrs.clear()
+    this.reservationStore.cancelReservations()
+    this.listeningAddrs = []
 
     // remove listener
     this.reservationStore.removeEventListener('relay:removed', this._onRemoveRelayPeer)