libp2p 0.42.2 → 0.43.0

package/src/circuit/transport/reservation-store.ts

@@ -0,0 +1,249 @@
+import type { PeerId } from '@libp2p/interface-peer-id'
+import { PeerMap } from '@libp2p/peer-collections'
+import PQueue from 'p-queue'
+import { DEFAULT_RESERVATION_CONCURRENCY, RELAY_TAG, RELAY_V2_HOP_CODEC } from '../constants.js'
+import { logger } from '@libp2p/logger'
+import { pbStream } from 'it-pb-stream'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { Connection } from '@libp2p/interface-connection'
+import type { Reservation } from '../pb/index.js'
+import { HopMessage, Status } from '../pb/index.js'
+import { getExpiration } from '../utils.js'
+import type { TransportManager } from '@libp2p/interface-transport'
+import type { Startable } from '@libp2p/interfaces/dist/src/startable.js'
+import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import { multiaddr } from '@multiformats/multiaddr'
+
+const log = logger('libp2p:circuit-relay:transport:reservation-store')
+
+// allow refreshing a relay reservation if it will expire in the next 10 minutes
+const REFRESH_WINDOW = (60 * 1000) * 10
+
+// try to refresh relay reservations 5 minutes before expiry
+const REFRESH_TIMEOUT = (60 * 1000) * 5
+
+export interface RelayStoreComponents {
+  peerId: PeerId
+  connectionManager: ConnectionManager
+  transportManager: TransportManager
+  peerStore: PeerStore
+}
+
+export interface RelayStoreInit {
+  /**
+   * Multiple relays may be discovered simultaneously - to prevent listening
+   * on too many relays, this value controls how many to attempt to reserve a
+   * slot on at once. If set to more than one, we may end up listening on
+   * more relays than the `maxReservations` value, but on networks with poor
+   * connectivity the user may wish to attempt to reserve on multiple relays
+   * simultaneously. (default: 1)
+   */
+  reservationConcurrency?: number
+
+  /**
+   * How many discovered relays to allow in the reservation store
+   */
+  discoverRelays?: number
+}
+
+export type RelayType = 'discovered' | 'configured'
+
+interface RelayEntry {
+  timeout: ReturnType<typeof setTimeout>
+  type: RelayType
+  reservation: Reservation
+}
+
+export interface ReservationStoreEvents {
+  'relay:not-enough-relays': CustomEvent
+  'relay:removed': CustomEvent<PeerId>
+}
+
+export class ReservationStore extends EventEmitter<ReservationStoreEvents> implements Startable {
+  private readonly peerId: PeerId
+  private readonly connectionManager: ConnectionManager
+  private readonly transportManager: TransportManager
+  private readonly peerStore: PeerStore
+  private readonly reserveQueue: PQueue
+  private readonly reservations: PeerMap<RelayEntry>
+  private readonly maxDiscoveredRelays: number
+  private started: boolean
+
+  constructor (components: RelayStoreComponents, init?: RelayStoreInit) {
+    super()
+
+    this.peerId = components.peerId
+    this.connectionManager = components.connectionManager
+    this.transportManager = components.transportManager
+    this.peerStore = components.peerStore
+    this.reservations = new PeerMap()
+    this.maxDiscoveredRelays = init?.discoverRelays ?? 0
+    this.started = false
+
+    // ensure we don't listen on multiple relays simultaneously
+    this.reserveQueue = new PQueue({
+      concurrency: init?.reservationConcurrency ?? DEFAULT_RESERVATION_CONCURRENCY
+    })
+
+    // When a peer disconnects, if we had a reservation on that peer
+    // remove the reservation and multiaddr and maybe trigger search
+    // for new relays
+    this.connectionManager.addEventListener('peer:disconnect', (evt) => {
+      this.removeRelay(evt.detail.remotePeer)
+    })
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  async start (): Promise<void> {
+    this.started = true
+  }
+
+  async stop (): Promise<void> {
+    this.reservations.forEach(({ timeout }) => {
+      clearTimeout(timeout)
+    })
+    this.reservations.clear()
+
+    this.started = true
+  }
+
+  /**
+   * If the number of current relays is beneath the configured `maxReservations`
+   * value, and the passed peer id is not our own, and we have a non-relayed connection
+   * to the remote, and the remote peer speaks the hop protocol, try to reserve a slot
+   * on the remote peer
+   */
+  async addRelay (peerId: PeerId, type: RelayType): Promise<void> {
+    log('add relay', this.reserveQueue.size)
+
+    await this.reserveQueue.add(async () => {
+      try {
+        if (this.peerId.equals(peerId)) {
+          log('not trying to use self as relay')
+          return
+        }
+
+        // allow refresh of an existing reservation if it is about to expire
+        const existingReservation = this.reservations.get(peerId)
+
+        if (existingReservation != null) {
+          if (getExpiration(existingReservation.reservation.expire) > REFRESH_WINDOW) {
+            log('already have reservation on relay peer %p and it expires in more than 10 minutes', peerId)
+            return
+          }
+
+          clearTimeout(existingReservation.timeout)
+          this.reservations.delete(peerId)
+        }
+
+        if (type === 'discovered' && [...this.reservations.values()].reduce((acc, curr) => {
+          if (curr.type === 'discovered') {
+            acc++
+          }
+
+          return acc
+        }, 0) >= this.maxDiscoveredRelays) {
+          log('already have enough discovered relays')
+          return
+        }
+
+        const connection = await this.connectionManager.openConnection(peerId)
+
+        if (connection.remoteAddr.protoNames().includes('p2p-circuit')) {
+          log('not creating reservation over relayed connection')
+          return
+        }
+
+        const reservation = await this.#createReservation(connection)
+
+        log('created reservation on relay peer %p', peerId)
+
+        const expiration = getExpiration(reservation.expire)
+
+        const timeout = setTimeout(() => {
+          this.addRelay(peerId, type).catch(err => {
+            log.error('could not refresh reservation to relay %p', peerId, err)
+          })
+        }, Math.max(expiration - REFRESH_TIMEOUT, 0))
+
+        this.reservations.set(peerId, {
+          timeout,
+          reservation,
+          type
+        })
+
+        // ensure we don't close the connection to the relay
+        await this.peerStore.tagPeer(peerId, RELAY_TAG, {
+          value: 1,
+          ttl: expiration
+        })
+
+        await this.transportManager.listen(
+          reservation.addrs.map(ma => {
+            return multiaddr(ma).encapsulate('/p2p-circuit')
+          })
+        )
+      } catch (err) {
+        log.error('could not reserve slot on %p', peerId, err)
+      }
+    })
+  }
+
+  hasReservation (peerId: PeerId): boolean {
+    return this.reservations.has(peerId)
+  }
+
+  async #createReservation (connection: Connection): Promise<Reservation> {
+    log('requesting reservation from %s', connection.remotePeer)
+    const stream = await connection.newStream(RELAY_V2_HOP_CODEC)
+    const pbstr = pbStream(stream)
+    const hopstr = pbstr.pb(HopMessage)
+    hopstr.write({ type: HopMessage.Type.RESERVE })
+
+    let response: HopMessage
+
+    try {
+      response = await hopstr.read()
+    } catch (err: any) {
+      log.error('error parsing reserve message response from %s because', connection.remotePeer, err.message)
+      throw err
+    } finally {
+      stream.close()
+    }
+
+    if (response.status === Status.OK && (response.reservation != null)) {
+      return response.reservation
+    }
+
+    const errMsg = `reservation failed with status ${response.status ?? 'undefined'}`
+    log.error(errMsg)
+
+    throw new Error(errMsg)
+  }
+
+  /**
+   * Remove listen relay
+   */
+  removeRelay (peerId: PeerId): void {
+    const existingReservation = this.reservations.get(peerId)
+
+    if (existingReservation == null) {
+      return
+    }
+
+    log('removing relay %p', peerId)
+
+    clearTimeout(existingReservation.timeout)
+    this.reservations.delete(peerId)
+
+    this.safeDispatchEvent('relay:removed', { detail: peerId })
+
+    if (this.reservations.size < this.maxDiscoveredRelays) {
+      this.dispatchEvent(new CustomEvent('relay:not-enough-relays'))
+    }
+  }
+}

package/src/circuit/utils.ts

@@ -1,5 +1,106 @@
 import { CID } from 'multiformats/cid'
 import { sha256 } from 'multiformats/hashes/sha2'
+import type { Source } from 'it-stream-types'
+import type { Uint8ArrayList } from 'uint8arraylist'
+import type { Limit } from './pb/index.js'
+import { logger } from '@libp2p/logger'
+import type { Stream } from '@libp2p/interface-connection'
+import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT } from './constants.js'
+import { abortableSource } from 'abortable-iterator'
+import anySignal from 'any-signal'
+
+const log = logger('libp2p:circuit-relay:utils')
+
+async function * countStreamBytes (source: Source<Uint8Array | Uint8ArrayList>, limit: { remaining: bigint }): AsyncGenerator<Uint8Array | Uint8ArrayList, void, unknown> {
+  for await (const buf of source) {
+    const len = BigInt(buf.byteLength)
+
+    if ((limit.remaining - len) < 0) {
+      // this is a safe downcast since len is guarantee to be in the range for a number
+      const remaining = Number(limit.remaining)
+      limit.remaining = 0n
+
+      try {
+        if (remaining !== 0) {
+          yield buf.subarray(0, remaining)
+        }
+      } catch (err: any) {
+        log.error(err)
+      }
+
+      throw new Error('data limit exceeded')
+    }
+
+    limit.remaining -= len
+    yield buf
+  }
+}
+
+const doRelay = (src: Stream, dst: Stream, abortSignal: AbortSignal, limit: Required<Limit>): void => {
+  function abortStreams (err: Error): void {
+    src.abort(err)
+    dst.abort(err)
+    clearTimeout(timeout)
+  }
+
+  const abortController = new AbortController()
+  const signal = anySignal([abortSignal, abortController.signal])
+
+  const timeout = setTimeout(() => {
+    abortController.abort()
+  }, limit.duration)
+
+  let srcDstFinished = false
+  let dstSrcFinished = false
+
+  const dataLimit = {
+    remaining: limit.data
+  }
+
+  queueMicrotask(() => {
+    void dst.sink(countStreamBytes(abortableSource(src.source, signal, {
+      abortMessage: 'duration limit exceeded'
+    }), dataLimit))
+      .catch(err => {
+        log.error('error while relaying streams src -> dst', err)
+        abortStreams(err)
+      })
+      .finally(() => {
+        srcDstFinished = true
+
+        if (dstSrcFinished) {
+          clearTimeout(timeout)
+        }
+      })
+  })
+
+  queueMicrotask(() => {
+    void src.sink(countStreamBytes(abortableSource(dst.source, signal, {
+      abortMessage: 'duration limit exceeded'
+    }), dataLimit))
+      .catch(err => {
+        log.error('error while relaying streams dst -> src', err)
+        abortStreams(err)
+      })
+      .finally(() => {
+        dstSrcFinished = true
+
+        if (srcDstFinished) {
+          clearTimeout(timeout)
+        }
+      })
+  })
+}
+
+export function createLimitedRelay (source: Stream, destination: Stream, abortSignal: AbortSignal, limit?: Limit): void {
+  const dataLimit = limit?.data ?? BigInt(DEFAULT_DATA_LIMIT)
+  const durationLimit = limit?.duration ?? DEFAULT_DURATION_LIMIT
+
+  doRelay(source, destination, abortSignal, {
+    data: dataLimit,
+    duration: durationLimit
+  })
+}
 
 /**
  * Convert a namespace string into a cid
@@ -10,3 +111,10 @@ export async function namespaceToCid (namespace: string): Promise<CID> {
 
   return CID.createV0(hash)
 }
+
+/**
+ * returns number of ms between now and expiration time
+ */
+export function getExpiration (expireTime: bigint): number {
+  return Number(expireTime) - new Date().getTime()
+}

package/src/components.ts

@@ -1,5 +1,5 @@
-import errCode from 'err-code'
-import type { ConnectionGater, ConnectionProtector } from '@libp2p/interface-connection'
+import { CodeError } from '@libp2p/interfaces/errors'
+import type { ConnectionProtector } from '@libp2p/interface-connection'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { AddressManager } from '@libp2p/interface-address-manager'
 import { isStartable, Startable } from '@libp2p/interfaces/startable'
@@ -13,6 +13,7 @@ import type { Datastore } from 'interface-datastore'
 import type { PubSub } from '@libp2p/interface-pubsub'
 import type { DualDHT } from '@libp2p/interface-dht'
 import type { ConnectionManager, Dialer } from '@libp2p/interface-connection-manager'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
 
 export interface Components {
   peerId: PeerId
@@ -90,11 +91,11 @@ export class DefaultComponents implements Components, Startable {
     this._dialer = init.dialer
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this._started
   }
 
-  async beforeStart () {
+  async beforeStart (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         if (startable.beforeStart != null) {
@@ -104,7 +105,7 @@ export class DefaultComponents implements Components, Startable {
     )
   }
 
-  async start () {
+  async start (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         await startable.start()
@@ -114,7 +115,7 @@ export class DefaultComponents implements Components, Startable {
     this._started = true
   }
 
-  async afterStart () {
+  async afterStart (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         if (startable.afterStart != null) {
@@ -124,7 +125,7 @@ export class DefaultComponents implements Components, Startable {
     )
   }
 
-  async beforeStop () {
+  async beforeStop (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         if (startable.beforeStop != null) {
@@ -134,7 +135,7 @@ export class DefaultComponents implements Components, Startable {
     )
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         await startable.stop()
@@ -144,7 +145,7 @@ export class DefaultComponents implements Components, Startable {
     this._started = false
   }
 
-  async afterStop () {
+  async afterStop (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         if (startable.afterStop != null) {
@@ -156,7 +157,7 @@ export class DefaultComponents implements Components, Startable {
 
   get peerId (): PeerId {
     if (this._peerId == null) {
-      throw errCode(new Error('peerId not set'), 'ERR_SERVICE_MISSING')
+      throw new CodeError('peerId not set', 'ERR_SERVICE_MISSING')
     }
 
     return this._peerId
@@ -168,7 +169,7 @@ export class DefaultComponents implements Components, Startable {
 
   get addressManager (): AddressManager {
     if (this._addressManager == null) {
-      throw errCode(new Error('addressManager not set'), 'ERR_SERVICE_MISSING')
+      throw new CodeError('addressManager not set', 'ERR_SERVICE_MISSING')
     }
 
     return this._addressManager
@@ -180,7 +181,7 @@ export class DefaultComponents implements Components, Startable {
 
   get peerStore (): PeerStore {
     if (this._peerStore == null) {
-      throw errCode(new Error('peerStore not set'), 'ERR_SERVICE_MISSING')
+      throw new CodeError('peerStore not set', 'ERR_SERVICE_MISSING')
     }
 
     return this._peerStore
@@ -192,7 +193,7 @@ export class DefaultComponents implements Components, Startable {
 
   get upgrader (): Upgrader {
     if (this._upgrader == null) {
-      throw errCode(new Error('upgrader not set'), 'ERR_SERVICE_MISSING')
+      throw new CodeError('upgrader not set', 'ERR_SERVICE_MISSING')
     }
 
     return this._upgrader
@@ -204,7 +205,7 @@ export class DefaultComponents implements Components, Startable {
 
   get registrar (): Registrar {
     if (this._registrar == null) {
-      throw errCode(new Error('registrar not set'), 'ERR_SERVICE_MISSING')
+      throw new CodeError('registrar not set', 'ERR_SERVICE_MISSING')
     }
 
     return this._registrar
@@ -216,7 +217,7 @@ export class DefaultComponents implements Components, Startable {
 
   get connectionManager (): ConnectionManager {
     if (this._connectionManager == null) {
-      throw errCode(new Error('connectionManager not set'), 'ERR_SERVICE_MISSING')
+      throw new CodeError('connectionManager not set', 'ERR_SERVICE_MISSING')
     }
 
     return this._connectionManager
@@ -228,7 +229,7 @@ export class DefaultComponents implements Components, Startable {
 
   get transportManager (): TransportManager {
     if (this._transportManager == null) {
-      throw errCode(new Error('transportManager not set'), 'ERR_SERVICE_MISSING')
+      throw new CodeError('transportManager not set', 'ERR_SERVICE_MISSING')
     }
 
     return this._transportManager
@@ -240,7 +241,7 @@ export class DefaultComponents implements Components, Startable {
 
   get connectionGater (): ConnectionGater {
     if (this._connectionGater == null) {
-      throw errCode(new Error('connectionGater not set'), 'ERR_SERVICE_MISSING')
+      throw new CodeError('connectionGater not set', 'ERR_SERVICE_MISSING')
     }
 
     return this._connectionGater
@@ -252,7 +253,7 @@ export class DefaultComponents implements Components, Startable {
 
   get contentRouting (): ContentRouting {
     if (this._contentRouting == null) {
-      throw errCode(new Error('contentRouting not set'), 'ERR_SERVICE_MISSING')
+      throw new CodeError('contentRouting not set', 'ERR_SERVICE_MISSING')
     }
 
     return this._contentRouting
@@ -264,7 +265,7 @@ export class DefaultComponents implements Components, Startable {
 
   get peerRouting (): PeerRouting {
     if (this._peerRouting == null) {
-      throw errCode(new Error('peerRouting not set'), 'ERR_SERVICE_MISSING')
+      throw new CodeError('peerRouting not set', 'ERR_SERVICE_MISSING')
     }
 
     return this._peerRouting
@@ -276,7 +277,7 @@ export class DefaultComponents implements Components, Startable {
 
   get datastore (): Datastore {
     if (this._datastore == null) {
-      throw errCode(new Error('datastore not set'), 'ERR_SERVICE_MISSING')
+      throw new CodeError('datastore not set', 'ERR_SERVICE_MISSING')
     }
 
     return this._datastore
@@ -296,7 +297,7 @@ export class DefaultComponents implements Components, Startable {
 
   get dialer (): Dialer {
     if (this._dialer == null) {
-      throw errCode(new Error('dialer not set'), 'ERR_SERVICE_MISSING')
+      throw new CodeError('dialer not set', 'ERR_SERVICE_MISSING')
     }
 
     return this._dialer

package/src/config.ts

@@ -2,13 +2,12 @@ import mergeOptions from 'merge-options'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import * as Constants from './constants.js'
 import { AGENT_VERSION } from './identify/consts.js'
-import * as RelayConstants from './circuit/constants.js'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { FaultTolerance } from '@libp2p/interface-transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Libp2pInit } from './index.js'
 import { codes, messages } from './errors.js'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import type { RecursivePartial } from '@libp2p/interfaces'
 import { isNode, isBrowser, isWebWorker, isElectronMain, isElectronRenderer, isReactNative } from 'wherearewe'
 
@@ -22,7 +21,6 @@ const DefaultConfig: Partial<Libp2pInit> = {
   connectionManager: {
     maxConnections: 300,
     minConnections: 50,
-    autoDial: true,
     autoDialInterval: 10000,
     maxParallelDials: Constants.MAX_PARALLEL_DIALS,
     maxDialsPerPeer: Constants.MAX_PER_PEER_DIALS,
@@ -49,23 +47,6 @@ const DefaultConfig: Partial<Libp2pInit> = {
     ttl: 7200,
     keepAlive: true
   },
-  relay: {
-    enabled: true,
-    advertise: {
-      bootDelay: RelayConstants.ADVERTISE_BOOT_DELAY,
-      enabled: false,
-      ttl: RelayConstants.ADVERTISE_TTL
-    },
-    hop: {
-      enabled: false,
-      active: false,
-      timeout: 30000
-    },
-    autoRelay: {
-      enabled: false,
-      maxListeners: 2
-    }
-  },
   identify: {
     protocolPrefix: 'ipfs',
     host: {
@@ -76,11 +57,18 @@ const DefaultConfig: Partial<Libp2pInit> = {
     maxInboundStreams: 1,
     maxOutboundStreams: 1,
     maxPushIncomingStreams: 1,
-    maxPushOutgoingStreams: 1
+    maxPushOutgoingStreams: 1,
+    maxObservedAddresses: 10
   },
   ping: {
     protocolPrefix: 'ipfs',
-    maxInboundStreams: 1,
+    // See https://github.com/libp2p/specs/blob/d4b5fb0152a6bb86cfd9ea/ping/ping.md?plain=1#L38-L43
+    // The dialing peer MUST NOT keep more than one outbound stream for the ping protocol per peer.
+    // The listening peer SHOULD accept at most two streams per peer since cross-stream behavior is
+    // non-linear and stream writes occur asynchronously. The listening peer may perceive the
+    // dialing peer closing and opening the wrong streams (for instance, closing stream B and
+    // opening stream A even though the dialing peer is opening stream B and closing stream A).
+    maxInboundStreams: 2,
     maxOutboundStreams: 1,
     timeout: 10000
   },
@@ -89,6 +77,14 @@ const DefaultConfig: Partial<Libp2pInit> = {
     maxInboundStreams: 1,
     maxOutboundStreams: 1,
     timeout: 10000
+  },
+  autonat: {
+    protocolPrefix: 'libp2p',
+    maxInboundStreams: 1,
+    maxOutboundStreams: 1,
+    timeout: 30000,
+    startupDelay: 5000,
+    refreshInterval: 60000
   }
 }
 
@@ -96,15 +92,15 @@ export function validateConfig (opts: RecursivePartial<Libp2pInit>): Libp2pInit
   const resultingOptions: Libp2pInit = mergeOptions(DefaultConfig, opts)
 
   if (resultingOptions.transports == null || resultingOptions.transports.length < 1) {
-    throw errCode(new Error(messages.ERR_TRANSPORTS_REQUIRED), codes.ERR_TRANSPORTS_REQUIRED)
+    throw new CodeError(messages.ERR_TRANSPORTS_REQUIRED, codes.ERR_TRANSPORTS_REQUIRED)
   }
 
   if (resultingOptions.connectionEncryption == null || resultingOptions.connectionEncryption.length === 0) {
-    throw errCode(new Error(messages.CONN_ENCRYPTION_REQUIRED), codes.CONN_ENCRYPTION_REQUIRED)
+    throw new CodeError(messages.CONN_ENCRYPTION_REQUIRED, codes.CONN_ENCRYPTION_REQUIRED)
   }
 
   if (resultingOptions.connectionProtector === null && globalThis.process?.env?.LIBP2P_FORCE_PNET != null) { // eslint-disable-line no-undef
-    throw errCode(new Error(messages.ERR_PROTECTOR_REQUIRED), codes.ERR_PROTECTOR_REQUIRED)
+    throw new CodeError(messages.ERR_PROTECTOR_REQUIRED, codes.ERR_PROTECTOR_REQUIRED)
   }
 
   // Append user agent version to default AGENT_VERSION depending on the environment