@libp2p/circuit-relay-v2 3.2.23-cf9aab5c8 → 3.2.24-a02cb0461

package/src/server/index.ts

@@ -1,8 +1,8 @@
 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 { pbStream } from 'it-protobuf-stream'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import * as Digest from 'multiformats/hashes/digest'
 import {
@@ -18,50 +18,15 @@ 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 { ReservationStoreInit } from './reservation-store.js'
-import type { CircuitRelayService, RelayReservation } from '../index.js'
+import type { CircuitRelayServerComponents, CircuitRelayServerInit, CircuitRelayService, RelayReservation } from '../index.js'
 import type { Reservation } from '../pb/index.js'
-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 { Logger, Connection, Stream, PeerId, Startable, AbortOptions } from '@libp2p/interface'
 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
   request: HopMessage
@@ -73,18 +38,6 @@ 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>
@@ -95,14 +48,8 @@ const defaults = {
   maxOutboundStopStreams: MAX_CONNECTIONS
 }
 
-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
+export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements Startable, CircuitRelayService {
+  private readonly components: CircuitRelayServerComponents
   private readonly reservationStore: ReservationStore
   private started: boolean
   private readonly hopTimeout: number
@@ -119,13 +66,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
     super()
 
     this.log = components.logger.forComponent('libp2p:circuit-relay:server')
-    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.components = components
     this.started = false
     this.hopTimeout = init?.hopTimeout ?? DEFAULT_HOP_TIMEOUT
     this.maxInboundHopStreams = init.maxInboundHopStreams
@@ -135,6 +76,8 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
 
     this.shutdownController = new AbortController()
     setMaxListeners(Infinity, this.shutdownController.signal)
+
+    this.onHop = this.onHop.bind(this)
   }
 
   readonly [Symbol.toStringTag] = '@libp2p/circuit-relay-v2-server'
@@ -151,11 +94,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       return
     }
 
-    await this.registrar.handle(RELAY_V2_HOP_CODEC, (data) => {
-      void this.onHop(data).catch(err => {
-        this.log.error(err)
-      })
-    }, {
+    await this.components.registrar.handle(RELAY_V2_HOP_CODEC, this.onHop, {
       maxInboundStreams: this.maxInboundHopStreams,
       maxOutboundStreams: this.maxOutboundHopStreams,
       runOnLimitedConnection: true
@@ -170,16 +109,19 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
   async stop (): Promise<void> {
     this.reservationStore.clear()
     this.shutdownController.abort()
-    await this.registrar.unhandle(RELAY_V2_HOP_CODEC)
+    await this.components.registrar.unhandle(RELAY_V2_HOP_CODEC)
 
     this.started = false
   }
 
-  async onHop ({ connection, stream }: IncomingStreamData): Promise<void> {
+  async onHop (stream: Stream, connection: Connection): 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: AbortSignal.timeout(this.hopTimeout)
+      signal
     }
     const pbstr = pbStream(stream)
 
@@ -229,7 +171,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       return
     }
 
-    if ((await this.connectionGater.denyInboundRelayReservation?.(connection.remotePeer)) === true) {
+    if ((await this.components.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
@@ -247,12 +189,12 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       // 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.peerStore.merge(connection.remotePeer, {
+        await this.components.peerStore.merge(connection.remotePeer, {
           tags: {
             [RELAY_SOURCE_TAG]: { value: 1, ttl },
             [KEEP_ALIVE_SOURCE_TAG]: { value: 1, ttl }
           }
-        })
+        }, options)
       }
 
       await hopstr.write({
@@ -262,17 +204,20 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
         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.peerStore.merge(connection.remotePeer, {
+        await this.components.peerStore.merge(connection.remotePeer, {
           tags: {
             [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)
       }
@@ -285,7 +230,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
   ): Promise<Reservation> {
     const addrs = []
 
-    for (const relayAddr of this.addressManager.getAddresses()) {
+    for (const relayAddr of this.components.addressManager.getAddresses()) {
       if (relayAddr.toString().includes('/p2p-circuit')) {
         continue
       }
@@ -295,9 +240,9 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
 
     const envelope = await RecordEnvelope.seal(new ReservationVoucherRecord({
       peer: remotePeer,
-      relay: this.peerId,
+      relay: this.components.peerId,
       expiration: expire
-    }), this.privateKey)
+    }), this.components.privateKey)
 
     return {
       addrs,
@@ -307,7 +252,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
         payloadType: envelope.payloadType,
         payload: {
           peer: remotePeer.toMultihash().bytes,
-          relay: this.peerId.toMultihash().bytes,
+          relay: this.components.peerId.toMultihash().bytes,
           expiration: expire
         },
         signature: envelope.signature
@@ -350,13 +295,13 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       return
     }
 
-    if ((await this.connectionGater.denyOutboundRelayedConnection?.(connection.remotePeer, dstPeer)) === true) {
+    if ((await this.components.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.connectionManager.getConnections(dstPeer)
+    const connections = this.components.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)
@@ -389,12 +334,11 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       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(sourceStream, destinationStream, this.shutdownController.signal, reservation, {
+    createLimitedRelay(stream.unwrap(), destinationStream, this.shutdownController.signal, reservation, {
       log: this.log
     })
   }
@@ -404,7 +348,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
    */
   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
@@ -439,9 +383,3 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
     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 } from '../index.js'
+import type { RelayReservation, ServerReservationStoreInit } 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,46 +15,6 @@ 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
@@ -64,7 +24,7 @@ export class ReservationStore {
   private readonly defaultDataLimit: bigint
   private readonly log: Logger
 
-  constructor (components: ReservationStoreComponents, init: ReservationStoreInit = {}) {
+  constructor (components: ReservationStoreComponents, init: ServerReservationStoreInit = {}) {
     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,30 +1,12 @@
-import { PeerQueue } from '@libp2p/utils/peer-queue'
+import { PeerQueue } from '@libp2p/utils'
 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 { 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
-}
+import type { RelayDiscoveryComponents, RelayDiscoveryEvents, RelayDiscoveryInit } from '../index.ts'
+import type { Logger, Peer, PeerId, PeerInfo, Startable, TopologyFilter } from '@libp2p/interface'
 
 /**
  * ReservationManager automatically makes a circuit v2 reservation on any connected
@@ -221,7 +203,7 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
   }
 
   onPeer (evt: CustomEvent<PeerInfo>): void {
-    this.log.trace('maybe dialing discovered peer %p - %e', evt.detail.id)
+    this.log.trace('maybe dialing discovered peer %p', evt.detail.id)
 
     this.maybeDialPeer(evt)
       .catch(err => {