libp2p 0.42.2-593deefe → 0.42.2-5e63ee2d

package/src/autonat/pb/index.ts

@@ -0,0 +1,320 @@
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+
+import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime'
+import type { Codec } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export interface Message {
+  type?: Message.MessageType
+  dial?: Message.Dial
+  dialResponse?: Message.DialResponse
+}
+
+export namespace Message {
+  export enum MessageType {
+    DIAL = 'DIAL',
+    DIAL_RESPONSE = 'DIAL_RESPONSE'
+  }
+
+  enum __MessageTypeValues {
+    DIAL = 0,
+    DIAL_RESPONSE = 1
+  }
+
+  export namespace MessageType {
+    export const codec = (): Codec<MessageType> => {
+      return enumeration<MessageType>(__MessageTypeValues)
+    }
+  }
+
+  export enum ResponseStatus {
+    OK = 'OK',
+    E_DIAL_ERROR = 'E_DIAL_ERROR',
+    E_DIAL_REFUSED = 'E_DIAL_REFUSED',
+    E_BAD_REQUEST = 'E_BAD_REQUEST',
+    E_INTERNAL_ERROR = 'E_INTERNAL_ERROR'
+  }
+
+  enum __ResponseStatusValues {
+    OK = 0,
+    E_DIAL_ERROR = 100,
+    E_DIAL_REFUSED = 101,
+    E_BAD_REQUEST = 200,
+    E_INTERNAL_ERROR = 300
+  }
+
+  export namespace ResponseStatus {
+    export const codec = (): Codec<ResponseStatus> => {
+      return enumeration<ResponseStatus>(__ResponseStatusValues)
+    }
+  }
+
+  export interface PeerInfo {
+    id?: Uint8Array
+    addrs: Uint8Array[]
+  }
+
+  export namespace PeerInfo {
+    let _codec: Codec<PeerInfo>
+
+    export const codec = (): Codec<PeerInfo> => {
+      if (_codec == null) {
+        _codec = message<PeerInfo>((obj, w, opts = {}) => {
+          if (opts.lengthDelimited !== false) {
+            w.fork()
+          }
+
+          if (obj.id != null) {
+            w.uint32(10)
+            w.bytes(obj.id)
+          }
+
+          if (obj.addrs != null) {
+            for (const value of obj.addrs) {
+              w.uint32(18)
+              w.bytes(value)
+            }
+          }
+
+          if (opts.lengthDelimited !== false) {
+            w.ldelim()
+          }
+        }, (reader, length) => {
+          const obj: any = {
+            addrs: []
+          }
+
+          const end = length == null ? reader.len : reader.pos + length
+
+          while (reader.pos < end) {
+            const tag = reader.uint32()
+
+            switch (tag >>> 3) {
+              case 1:
+                obj.id = reader.bytes()
+                break
+              case 2:
+                obj.addrs.push(reader.bytes())
+                break
+              default:
+                reader.skipType(tag & 7)
+                break
+            }
+          }
+
+          return obj
+        })
+      }
+
+      return _codec
+    }
+
+    export const encode = (obj: Partial<PeerInfo>): Uint8Array => {
+      return encodeMessage(obj, PeerInfo.codec())
+    }
+
+    export const decode = (buf: Uint8Array | Uint8ArrayList): PeerInfo => {
+      return decodeMessage(buf, PeerInfo.codec())
+    }
+  }
+
+  export interface Dial {
+    peer?: Message.PeerInfo
+  }
+
+  export namespace Dial {
+    let _codec: Codec<Dial>
+
+    export const codec = (): Codec<Dial> => {
+      if (_codec == null) {
+        _codec = message<Dial>((obj, w, opts = {}) => {
+          if (opts.lengthDelimited !== false) {
+            w.fork()
+          }
+
+          if (obj.peer != null) {
+            w.uint32(10)
+            Message.PeerInfo.codec().encode(obj.peer, w)
+          }
+
+          if (opts.lengthDelimited !== false) {
+            w.ldelim()
+          }
+        }, (reader, length) => {
+          const obj: any = {}
+
+          const end = length == null ? reader.len : reader.pos + length
+
+          while (reader.pos < end) {
+            const tag = reader.uint32()
+
+            switch (tag >>> 3) {
+              case 1:
+                obj.peer = Message.PeerInfo.codec().decode(reader, reader.uint32())
+                break
+              default:
+                reader.skipType(tag & 7)
+                break
+            }
+          }
+
+          return obj
+        })
+      }
+
+      return _codec
+    }
+
+    export const encode = (obj: Partial<Dial>): Uint8Array => {
+      return encodeMessage(obj, Dial.codec())
+    }
+
+    export const decode = (buf: Uint8Array | Uint8ArrayList): Dial => {
+      return decodeMessage(buf, Dial.codec())
+    }
+  }
+
+  export interface DialResponse {
+    status?: Message.ResponseStatus
+    statusText?: string
+    addr?: Uint8Array
+  }
+
+  export namespace DialResponse {
+    let _codec: Codec<DialResponse>
+
+    export const codec = (): Codec<DialResponse> => {
+      if (_codec == null) {
+        _codec = message<DialResponse>((obj, w, opts = {}) => {
+          if (opts.lengthDelimited !== false) {
+            w.fork()
+          }
+
+          if (obj.status != null) {
+            w.uint32(8)
+            Message.ResponseStatus.codec().encode(obj.status, w)
+          }
+
+          if (obj.statusText != null) {
+            w.uint32(18)
+            w.string(obj.statusText)
+          }
+
+          if (obj.addr != null) {
+            w.uint32(26)
+            w.bytes(obj.addr)
+          }
+
+          if (opts.lengthDelimited !== false) {
+            w.ldelim()
+          }
+        }, (reader, length) => {
+          const obj: any = {}
+
+          const end = length == null ? reader.len : reader.pos + length
+
+          while (reader.pos < end) {
+            const tag = reader.uint32()
+
+            switch (tag >>> 3) {
+              case 1:
+                obj.status = Message.ResponseStatus.codec().decode(reader)
+                break
+              case 2:
+                obj.statusText = reader.string()
+                break
+              case 3:
+                obj.addr = reader.bytes()
+                break
+              default:
+                reader.skipType(tag & 7)
+                break
+            }
+          }
+
+          return obj
+        })
+      }
+
+      return _codec
+    }
+
+    export const encode = (obj: Partial<DialResponse>): Uint8Array => {
+      return encodeMessage(obj, DialResponse.codec())
+    }
+
+    export const decode = (buf: Uint8Array | Uint8ArrayList): DialResponse => {
+      return decodeMessage(buf, DialResponse.codec())
+    }
+  }
+
+  let _codec: Codec<Message>
+
+  export const codec = (): Codec<Message> => {
+    if (_codec == null) {
+      _codec = message<Message>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if (obj.type != null) {
+          w.uint32(8)
+          Message.MessageType.codec().encode(obj.type, w)
+        }
+
+        if (obj.dial != null) {
+          w.uint32(18)
+          Message.Dial.codec().encode(obj.dial, w)
+        }
+
+        if (obj.dialResponse != null) {
+          w.uint32(26)
+          Message.DialResponse.codec().encode(obj.dialResponse, w)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.type = Message.MessageType.codec().decode(reader)
+              break
+            case 2:
+              obj.dial = Message.Dial.codec().decode(reader, reader.uint32())
+              break
+            case 3:
+              obj.dialResponse = Message.DialResponse.codec().decode(reader, reader.uint32())
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
+  }
+
+  export const encode = (obj: Partial<Message>): Uint8Array => {
+    return encodeMessage(obj, Message.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Message => {
+    return decodeMessage(buf, Message.codec())
+  }
+}

package/src/circuit/constants.ts

@@ -1,4 +1,5 @@
-const minute = 60 * 1000
+const second = 1000
+const minute = 60 * second
 
 /**
  * Delay before HOP relay service is advertised on the network
@@ -21,17 +22,51 @@ export const CIRCUIT_PROTO_CODE = 290
 export const RELAY_RENDEZVOUS_NS = '/libp2p/relay'
 
 /**
- * Maximum reservations for auto relay
+ * The maximum number of relay reservations the relay server will accept
  */
-export const DEFAULT_MAX_RESERVATIONS = 1
+export const DEFAULT_MAX_RESERVATION_STORE_SIZE = 15
 
-export const RELAY_DESTINATION_TAG = 'relay-destination'
+/**
+ * How often to check for reservation expiry
+ */
+export const DEFAULT_MAX_RESERVATION_CLEAR_INTERVAL = 300 * second
+
+/**
+ * How often to check for reservation expiry
+ */
+export const DEFAULT_MAX_RESERVATION_TTL = 2 * 60 * minute
+
+export const DEFAULT_RESERVATION_CONCURRENCY = 1
+
+export const RELAY_SOURCE_TAG = 'circuit-relay-source'
+
+export const RELAY_TAG = 'circuit-relay-relay'
 
 // circuit v2 connection limits
 // https://github.com/libp2p/go-libp2p/blob/master/p2p/protocol/circuitv2/relay/resources.go#L61-L66
 
 // 2 min is the default connection duration
-export const DEFAULT_DURATION_LIMIT = 2 * 60 * 1000
+export const DEFAULT_DURATION_LIMIT = 2 * minute
 
 // 128k is the default data limit
 export const DEFAULT_DATA_LIMIT = BigInt(1 << 17)
+
+/**
+ * The hop protocol
+ */
+export const RELAY_V2_HOP_CODEC = '/libp2p/circuit/relay/0.2.0/hop'
+
+/**
+ * the stop protocol
+ */
+export const RELAY_V2_STOP_CODEC = '/libp2p/circuit/relay/0.2.0/stop'
+
+/**
+ * Hop messages must be exchanged inside this timeout
+ */
+export const DEFAULT_HOP_TIMEOUT = 30 * second
+
+/**
+ * How long to wait before starting to advertise the relay service
+ */
+export const DEFAULT_ADVERT_BOOT_DELAY = 30 * second

package/src/circuit/index.ts

@@ -1,73 +1,23 @@
-/**
- * RelayConfig configures the circuit v2 relay transport.
- */
-export interface RelayConfig {
-  /**
-   * Enable dialing a client over a relay and receiving relayed connections.
-   * This in itself does not enable the node to act as a relay.
-   */
-  enabled: boolean
-  advertise: RelayAdvertiseConfig
-  hop: HopConfig
-  reservationManager: RelayReservationManagerConfig
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { PeerMap } from '@libp2p/peer-collections'
+import type { Limit } from './pb/index.js'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export interface RelayReservation {
+  expire: Date
+  addr: Multiaddr
+  limit?: Limit
 }
 
-/**
- * RelayReservationManagerConfig allows the node to automatically listen
- * on any discovered relays upto a specified maximum.
- */
-export interface RelayReservationManagerConfig {
-  /**
-   * enable or disable autorelay (default: false)
-   */
-  enabled?: boolean
-
-  /**
-   * maximum number of relays to listen (default: 1)
-   */
-  maxReservations?: number
-}
-
-/**
- * Configures using the node as a HOP relay
- */
-export interface HopConfig {
-  /**
-   * If true this node will function as a limited relay (default: false)
-   */
-  enabled?: boolean
-
-  /**
-   * timeout for hop requests to complete
-   */
-  timeout: number
-
-  /**
-   * If false, no connection limits will be applied to relayed connections (default: true)
-   */
-  applyConnectionLimits?: boolean
-
-  /**
-   * Limits to apply to incoming relay connections - relayed connections will be closed if
-   * these limits are exceeded.
-   */
-  limit?: {
-    /**
-     * How long to relay a connection for in milliseconds (default: 2m)
-     */
-    duration?: number
-
-    /**
-     * How many bytes to allow to be transferred over a relayed connection (default: 128k)
-     */
-    data?: bigint
-  }
+export interface CircuitRelayServiceEvents {
+  'relay:reservation': CustomEvent<RelayReservation>
+  'relay:advert:success': CustomEvent<unknown>
+  'relay:advert:error': CustomEvent<Error>
 }
 
-export interface RelayAdvertiseConfig {
-  bootDelay?: number
-  enabled?: boolean
-  ttl?: number
+export interface CircuitRelayService extends EventEmitter<CircuitRelayServiceEvents> {
+  reservations: PeerMap<RelayReservation>
 }
 
-export { Relay } from './relay.js'
+export { circuitRelayServer } from './server/index.js'
+export { circuitRelayTransport } from './transport/index.js'

package/src/circuit/server/advert-service.ts

@@ -0,0 +1,108 @@
+import { logger } from '@libp2p/logger'
+import { codes } from '../../errors.js'
+import { namespaceToCid } from '../utils.js'
+import {
+  DEFAULT_ADVERT_BOOT_DELAY,
+  RELAY_RENDEZVOUS_NS
+} from '../constants.js'
+import type { Startable } from '@libp2p/interfaces/startable'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
+import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import pRetry from 'p-retry'
+
+const log = logger('libp2p:circuit-relay:advert-service')
+
+export interface AdvertServiceInit {
+  /**
+   * How long to wait after startup to begin advertising the service
+   * - if some configured content routers take a while to warm up (for
+   * example, the DHT needs some peers to be able to publish) this
+   * value should be high enough that they will have warmed up
+   */
+  bootDelay?: number
+}
+
+export interface AdvertServiceComponents {
+  contentRouting: ContentRouting
+}
+
+export interface AdvertServiceEvents {
+  'advert:success': CustomEvent<unknown>
+  'advert:error': CustomEvent<Error>
+}
+
+export class AdvertService extends EventEmitter<AdvertServiceEvents> implements Startable {
+  private readonly contentRouting: ContentRouting
+  private timeout?: any
+  private started: boolean
+  private readonly bootDelay: number
+
+  /**
+   * Creates an instance of Relay
+   */
+  constructor (components: AdvertServiceComponents, init?: AdvertServiceInit) {
+    super()
+
+    this.contentRouting = components.contentRouting
+    this.bootDelay = init?.bootDelay ?? DEFAULT_ADVERT_BOOT_DELAY
+    this.started = false
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  /**
+   * Start Relay service
+   */
+  start (): void {
+    if (this.started) {
+      return
+    }
+
+    // Advertise service if HOP enabled and advertising enabled
+    this.timeout = setTimeout(() => {
+      this._advertiseService().catch(err => {
+        log.error('could not advertise service', err)
+      })
+    }, this.bootDelay)
+
+    this.started = true
+  }
+
+  /**
+   * Stop Relay service
+   */
+  stop (): void {
+    try {
+      clearTimeout(this.timeout)
+    } catch (err) { }
+
+    this.started = false
+  }
+
+  /**
+   * Advertise hop relay service in the network.
+   */
+  async _advertiseService (): Promise<void> {
+    await pRetry(async () => {
+      try {
+        const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
+        await this.contentRouting.provide(cid)
+
+        this.dispatchEvent(new CustomEvent('advert:success'))
+      } catch (err: any) {
+        this.safeDispatchEvent('advert:error', { detail: err })
+
+        if (err.code === codes.ERR_NO_ROUTERS_AVAILABLE) {
+          log.error('a content router, such as a DHT, must be provided in order to advertise the relay service', err)
+          this.stop()
+          return
+        }
+
+        log.error('could not advertise service', err)
+        throw err
+      }
+    })
+  }
+}