@libp2p/circuit-relay-v2 3.2.24-6059227cb → 3.2.24-87bc8d4fb

package/src/server/index.ts

@@ -1,13 +1,14 @@
 import { publicKeyToProtobuf } from '@libp2p/crypto/keys'
 import { peerIdFromMultihash } from '@libp2p/peer-id'
 import { RecordEnvelope } from '@libp2p/peer-record'
-import { pbStream } from '@libp2p/utils'
 import { multiaddr } from '@multiformats/multiaddr'
-import { Circuit } from '@multiformats/multiaddr-matcher'
+import { pbStream } from 'it-protobuf-stream'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import * as Digest from 'multiformats/hashes/digest'
 import {
+  CIRCUIT_PROTO_CODE,
   DEFAULT_HOP_TIMEOUT,
+  KEEP_ALIVE_SOURCE_TAG,
   MAX_CONNECTIONS,
   RELAY_SOURCE_TAG,
   RELAY_V2_HOP_CODEC,
@@ -17,11 +18,49 @@ import { HopMessage, Status, StopMessage } from '../pb/index.js'
 import { createLimitedRelay } from '../utils.js'
 import { ReservationStore } from './reservation-store.js'
 import { ReservationVoucherRecord } from './reservation-voucher.js'
-import type { CircuitRelayServerComponents, CircuitRelayServerInit, CircuitRelayService, RelayReservation } from '../index.js'
+import type { ReservationStoreInit } from './reservation-store.js'
+import type { CircuitRelayService, RelayReservation } from '../index.js'
 import type { Reservation } from '../pb/index.js'
-import type { Logger, Connection, Stream, PeerId, Startable, AbortOptions } from '@libp2p/interface'
+import type { ComponentLogger, Logger, Connection, Stream, ConnectionGater, PeerId, PeerStore, Startable, PrivateKey, Metrics, AbortOptions, IncomingStreamData } from '@libp2p/interface'
+import type { AddressManager, ConnectionManager, Registrar } from '@libp2p/interface-internal'
 import type { PeerMap } from '@libp2p/peer-collections'
-import type { ProtobufStream } from '@libp2p/utils'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { ProtobufStream } from 'it-protobuf-stream'
+
+const isRelayAddr = (ma: Multiaddr): boolean => ma.protoCodes().includes(CIRCUIT_PROTO_CODE)
+
+export interface CircuitRelayServerInit {
+  /**
+   * Incoming hop requests must complete within this time in ms otherwise
+   * the stream will be reset
+   *
+   * @default 30000
+   */
+  hopTimeout?: number
+
+  /**
+   * Configuration of reservations
+   */
+  reservations?: ReservationStoreInit
+
+  /**
+   * The maximum number of simultaneous HOP inbound streams that can be open at once
+   */
+  maxInboundHopStreams?: number
+
+  /**
+   * The maximum number of simultaneous HOP outbound streams that can be open at once
+   */
+  maxOutboundHopStreams?: number
+
+  /**
+   * The maximum number of simultaneous STOP outbound streams that can be open at
+   * once.
+   *
+   * @default 300
+   */
+  maxOutboundStopStreams?: number
+}
 
 export interface HopProtocolOptions {
   connection: Connection
@@ -34,6 +73,18 @@ export interface StopOptions {
   request: StopMessage
 }
 
+export interface CircuitRelayServerComponents {
+  registrar: Registrar
+  peerStore: PeerStore
+  addressManager: AddressManager
+  peerId: PeerId
+  privateKey: PrivateKey
+  connectionManager: ConnectionManager
+  connectionGater: ConnectionGater
+  logger: ComponentLogger
+  metrics?: Metrics
+}
+
 export interface RelayServerEvents {
   'relay:reservation': CustomEvent<RelayReservation>
   'relay:advert:success': CustomEvent<unknown>
@@ -44,8 +95,14 @@ const defaults = {
   maxOutboundStopStreams: MAX_CONNECTIONS
 }
 
-export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements Startable, CircuitRelayService {
-  private readonly components: CircuitRelayServerComponents
+class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements Startable, CircuitRelayService {
+  private readonly registrar: Registrar
+  private readonly peerStore: PeerStore
+  private readonly addressManager: AddressManager
+  private readonly peerId: PeerId
+  private readonly privateKey: PrivateKey
+  private readonly connectionManager: ConnectionManager
+  private readonly connectionGater: ConnectionGater
   private readonly reservationStore: ReservationStore
   private started: boolean
   private readonly hopTimeout: number
@@ -62,7 +119,13 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
     super()
 
     this.log = components.logger.forComponent('libp2p:circuit-relay:server')
-    this.components = components
+    this.registrar = components.registrar
+    this.peerStore = components.peerStore
+    this.addressManager = components.addressManager
+    this.peerId = components.peerId
+    this.privateKey = components.privateKey
+    this.connectionManager = components.connectionManager
+    this.connectionGater = components.connectionGater
     this.started = false
     this.hopTimeout = init?.hopTimeout ?? DEFAULT_HOP_TIMEOUT
     this.maxInboundHopStreams = init.maxInboundHopStreams
@@ -72,8 +135,6 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
 
     this.shutdownController = new AbortController()
     setMaxListeners(Infinity, this.shutdownController.signal)
-
-    this.onHop = this.onHop.bind(this)
   }
 
   readonly [Symbol.toStringTag] = '@libp2p/circuit-relay-v2-server'
@@ -90,7 +151,11 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
       return
     }
 
-    await this.components.registrar.handle(RELAY_V2_HOP_CODEC, this.onHop, {
+    await this.registrar.handle(RELAY_V2_HOP_CODEC, (data) => {
+      void this.onHop(data).catch(err => {
+        this.log.error(err)
+      })
+    }, {
       maxInboundStreams: this.maxInboundHopStreams,
       maxOutboundStreams: this.maxOutboundHopStreams,
       runOnLimitedConnection: true
@@ -105,19 +170,16 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
   async stop (): Promise<void> {
     this.reservationStore.clear()
     this.shutdownController.abort()
-    await this.components.registrar.unhandle(RELAY_V2_HOP_CODEC)
+    await this.registrar.unhandle(RELAY_V2_HOP_CODEC)
 
     this.started = false
   }
 
-  async onHop (stream: Stream, connection: Connection): Promise<void> {
+  async onHop ({ connection, stream }: IncomingStreamData): Promise<void> {
     this.log('received circuit v2 hop protocol stream from %p', connection.remotePeer)
 
-    const signal = AbortSignal.timeout(this.hopTimeout)
-    setMaxListeners(Infinity, signal)
-
     const options = {
-      signal
+      signal: AbortSignal.timeout(this.hopTimeout)
     }
     const pbstr = pbStream(stream)
 
@@ -161,13 +223,13 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
     const hopstr = stream.pb(HopMessage)
     this.log('hop reserve request from %p', connection.remotePeer)
 
-    if (Circuit.exactMatch(connection.remoteAddr)) {
+    if (isRelayAddr(connection.remoteAddr)) {
       this.log.error('relay reservation over circuit connection denied for peer: %p', connection.remotePeer)
       await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED }, options)
       return
     }
 
-    if ((await this.components.connectionGater.denyInboundRelayReservation?.(connection.remotePeer)) === true) {
+    if ((await this.connectionGater.denyInboundRelayReservation?.(connection.remotePeer)) === true) {
       this.log.error('reservation for %p denied by connection gater', connection.remotePeer)
       await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED }, options)
       return
@@ -185,11 +247,12 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
       // result.expire is non-null if `ReservationStore.reserve` returns with status == OK
       if (result.expire != null) {
         const ttl = (result.expire * 1000) - Date.now()
-        await this.components.peerStore.merge(connection.remotePeer, {
+        await this.peerStore.merge(connection.remotePeer, {
           tags: {
-            [RELAY_SOURCE_TAG]: { value: 1, ttl }
+            [RELAY_SOURCE_TAG]: { value: 1, ttl },
+            [KEEP_ALIVE_SOURCE_TAG]: { value: 1, ttl }
           }
-        }, options)
+        })
       }
 
       await hopstr.write({
@@ -199,19 +262,17 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
         limit: this.reservationStore.get(connection.remotePeer)?.limit
       }, options)
       this.log('sent confirmation response to %s', connection.remotePeer)
-
-      // close writable end of stream
-      await hopstr.unwrap().unwrap().close(options)
     } catch (err) {
       this.log.error('failed to send confirmation response to %p - %e', connection.remotePeer, err)
       this.reservationStore.removeReservation(connection.remotePeer)
 
       try {
-        await this.components.peerStore.merge(connection.remotePeer, {
+        await this.peerStore.merge(connection.remotePeer, {
           tags: {
-            [RELAY_SOURCE_TAG]: undefined
+            [RELAY_SOURCE_TAG]: undefined,
+            [KEEP_ALIVE_SOURCE_TAG]: undefined
           }
-        }, options)
+        })
       } catch (err) {
         this.log.error('failed to untag relay source peer %p - %e', connection.remotePeer, err)
       }
@@ -224,7 +285,7 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
   ): Promise<Reservation> {
     const addrs = []
 
-    for (const relayAddr of this.components.addressManager.getAddresses()) {
+    for (const relayAddr of this.addressManager.getAddresses()) {
       if (relayAddr.toString().includes('/p2p-circuit')) {
         continue
       }
@@ -234,9 +295,9 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
 
     const envelope = await RecordEnvelope.seal(new ReservationVoucherRecord({
       peer: remotePeer,
-      relay: this.components.peerId,
+      relay: this.peerId,
       expiration: expire
-    }), this.components.privateKey)
+    }), this.privateKey)
 
     return {
       addrs,
@@ -246,7 +307,7 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
         payloadType: envelope.payloadType,
         payload: {
           peer: remotePeer.toMultihash().bytes,
-          relay: this.components.peerId.toMultihash().bytes,
+          relay: this.peerId.toMultihash().bytes,
           expiration: expire
         },
         signature: envelope.signature
@@ -257,7 +318,7 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
   async handleConnect ({ stream, request, connection }: HopProtocolOptions, options: AbortOptions): Promise<void> {
     const hopstr = stream.pb(HopMessage)
 
-    if (Circuit.matches(connection.remoteAddr)) {
+    if (isRelayAddr(connection.remoteAddr)) {
       this.log.error('relay reservation over circuit connection denied for peer: %p', connection.remotePeer)
       await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED }, options)
       return
@@ -289,13 +350,13 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
       return
     }
 
-    if ((await this.components.connectionGater.denyOutboundRelayedConnection?.(connection.remotePeer, dstPeer)) === true) {
+    if ((await this.connectionGater.denyOutboundRelayedConnection?.(connection.remotePeer, dstPeer)) === true) {
       this.log.error('hop connect for %p to %p denied by connection gater', connection.remotePeer, dstPeer)
       await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED }, options)
       return
     }
 
-    const connections = this.components.connectionManager.getConnections(dstPeer)
+    const connections = this.connectionManager.getConnections(dstPeer)
 
     if (connections.length === 0) {
       this.log('hop connect denied for destination peer %p not having a connection for %p as there is no destination connection', dstPeer, connection.remotePeer)
@@ -328,11 +389,12 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
       status: Status.OK,
       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(stream.unwrap(), destinationStream, this.shutdownController.signal, reservation, {
+    createLimitedRelay(sourceStream, destinationStream, this.shutdownController.signal, reservation, {
       log: this.log
     })
   }
@@ -342,7 +404,7 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
    */
   async stopHop ({ connection, request }: StopOptions, options: AbortOptions): Promise<Stream | undefined> {
     this.log('starting circuit relay v2 stop request to %s', connection.remotePeer)
-    const stream = await connection.newStream(RELAY_V2_STOP_CODEC, {
+    const stream = await connection.newStream([RELAY_V2_STOP_CODEC], {
       maxOutboundStreams: this.maxOutboundStopStreams,
       runOnLimitedConnection: true,
       ...options
@@ -377,3 +439,9 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
     return this.reservationStore.reservations
   }
 }
+
+export function circuitRelayServer (init: CircuitRelayServerInit = {}): (components: CircuitRelayServerComponents) => CircuitRelayService {
+  return (components) => {
+    return new CircuitRelayServer(components, init)
+  }
+}

package/src/server/reservation-store.ts

@@ -2,7 +2,7 @@ import { trackedPeerMap } from '@libp2p/peer-collections'
 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 { Status } from '../pb/index.js'
-import type { RelayReservation, ServerReservationStoreInit } from '../index.js'
+import type { RelayReservation } from '../index.js'
 import type { Limit } from '../pb/index.js'
 import type { ComponentLogger, Logger, Metrics, PeerId } from '@libp2p/interface'
 import type { PeerMap } from '@libp2p/peer-collections'
@@ -15,6 +15,46 @@ export interface ReservationStoreComponents {
   metrics?: Metrics
 }
 
+export interface ReservationStoreInit {
+  /**
+   * maximum number of reservations allowed
+   *
+   * @default 15
+   */
+  maxReservations?: number
+
+  /**
+   * interval after which stale reservations are cleared
+   *
+   * @default 300000
+   */
+  reservationClearInterval?: number
+
+  /**
+   * apply default relay limits to a new reservation
+   *
+   * @default true
+   */
+  applyDefaultLimit?: boolean
+
+  /**
+   * reservation ttl
+   *
+   * @default 7200000
+   */
+  reservationTtl?: number
+
+  /**
+   * The maximum time a relayed connection can be open for
+   */
+  defaultDurationLimit?: number
+
+  /**
+   * The maximum amount of data allowed to be transferred over a relayed connection
+   */
+  defaultDataLimit?: bigint
+}
+
 export class ReservationStore {
   public readonly reservations: PeerMap<RelayReservation>
   private readonly maxReservations: number
@@ -24,7 +64,7 @@ export class ReservationStore {
   private readonly defaultDataLimit: bigint
   private readonly log: Logger
 
-  constructor (components: ReservationStoreComponents, init: ServerReservationStoreInit = {}) {
+  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.applyDefaultLimit = init.applyDefaultLimit !== false

package/src/transport/discovery.ts

@@ -1,12 +1,30 @@
-import { PeerQueue } from '@libp2p/utils'
+import { PeerQueue } from '@libp2p/utils/peer-queue'
 import { anySignal } from 'any-signal'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import {
   RELAY_V2_HOP_CODEC
 } from '../constants.js'
-import type { RelayDiscoveryComponents, RelayDiscoveryEvents, RelayDiscoveryInit } from '../index.ts'
-import type { Logger, Peer, PeerId, PeerInfo, Startable, TopologyFilter } from '@libp2p/interface'
+import type { ComponentLogger, Libp2pEvents, Logger, Peer, PeerId, PeerInfo, PeerStore, Startable, TopologyFilter, TypedEventTarget } from '@libp2p/interface'
+import type { ConnectionManager, RandomWalk, Registrar, TransportManager } from '@libp2p/interface-internal'
+
+export interface RelayDiscoveryEvents {
+  'relay:discover': CustomEvent<PeerId>
+}
+
+export interface RelayDiscoveryComponents {
+  peerStore: PeerStore
+  connectionManager: ConnectionManager
+  transportManager: TransportManager
+  registrar: Registrar
+  logger: ComponentLogger
+  randomWalk: RandomWalk
+  events: TypedEventTarget<Libp2pEvents>
+}
+
+export interface RelayDiscoveryInit {
+  filter?: TopologyFilter
+}
 
 /**
  * ReservationManager automatically makes a circuit v2 reservation on any connected
@@ -203,7 +221,7 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
   }
 
   onPeer (evt: CustomEvent<PeerInfo>): void {
-    this.log.trace('maybe dialing discovered peer %p', evt.detail.id)
+    this.log.trace('maybe dialing discovered peer %p - %e', evt.detail.id)
 
     this.maybeDialPeer(evt)
       .catch(err => {