libp2p 0.42.2 → 0.43.0

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
@@ -16,16 +17,56 @@ export const ADVERTISE_TTL = 30 * minute
 export const CIRCUIT_PROTO_CODE = 290
 
 /**
- * PeerStore metadaBook key for HOP relay service
+ * Relay HOP relay service namespace for discovery
  */
-export const HOP_METADATA_KEY = 'hop_relay'
+export const RELAY_RENDEZVOUS_NS = '/libp2p/relay'
 
 /**
- * PeerStore metadaBook value for HOP relay service
+ * The maximum number of relay reservations the relay server will accept
  */
-export const HOP_METADATA_VALUE = 'true'
+export const DEFAULT_MAX_RESERVATION_STORE_SIZE = 15
 
 /**
- * Relay HOP relay service namespace for discovery
+ * How often to check for reservation expiry
  */
-export const RELAY_RENDEZVOUS_NS = '/libp2p/relay'
+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 * 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,135 +1,23 @@
-import { logger } from '@libp2p/logger'
-import { codes } from '../errors.js'
-import {
-  setDelayedInterval,
-  clearDelayedInterval
-// @ts-expect-error set-delayed-interval does not export types
-} from 'set-delayed-interval'
-import { AutoRelay } from './auto-relay.js'
-import { namespaceToCid } from './utils.js'
-import {
-  RELAY_RENDEZVOUS_NS
-} from './constants.js'
-import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
-import type { Startable } from '@libp2p/interfaces/startable'
-import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { TransportManager } from '@libp2p/interface-transport'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { StreamHandlerOptions } from '@libp2p/interface-registrar'
-
-export interface RelayConfig extends StreamHandlerOptions {
-  enabled: boolean
-  advertise: RelayAdvertiseConfig
-  hop: HopConfig
-  autoRelay: AutoRelayConfig
-}
-
-export interface HopConfig {
-  enabled?: boolean
-  active?: boolean
-  timeout: number
-}
-
-const log = logger('libp2p:relay')
-
-export interface RelayAdvertiseConfig {
-  bootDelay?: number
-  enabled?: boolean
-  ttl?: number
-}
-
-export interface AutoRelayConfig {
-  enabled?: boolean
-
-  /**
-   * maximum number of relays to listen
-   */
-  maxListeners: number
+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
 }
 
-export interface RelayInit extends RelayConfig {
-  addressSorter?: AddressSorter
+export interface CircuitRelayServiceEvents {
+  'relay:reservation': CustomEvent<RelayReservation>
+  'relay:advert:success': CustomEvent<unknown>
+  'relay:advert:error': CustomEvent<Error>
 }
 
-export interface RelayComponents {
-  peerId: PeerId
-  contentRouting: ContentRouting
-  peerStore: PeerStore
-  connectionManager: ConnectionManager
-  transportManager: TransportManager
+export interface CircuitRelayService extends EventEmitter<CircuitRelayServiceEvents> {
+  reservations: PeerMap<RelayReservation>
 }
 
-export class Relay implements Startable {
-  private readonly components: RelayComponents
-  private readonly init: RelayInit
-  // @ts-expect-error this field isn't used anywhere?
-  private readonly autoRelay?: AutoRelay
-  private timeout?: any
-  private started: boolean
-
-  /**
-   * Creates an instance of Relay
-   */
-  constructor (components: RelayComponents, init: RelayInit) {
-    this.components = components
-    // Create autoRelay if enabled
-    this.autoRelay = init.autoRelay?.enabled !== false
-      ? new AutoRelay(components, {
-        addressSorter: init.addressSorter,
-        ...init.autoRelay
-      })
-      : undefined
-
-    this.started = false
-    this.init = init
-    this._advertiseService = this._advertiseService.bind(this)
-  }
-
-  isStarted () {
-    return this.started
-  }
-
-  /**
-   * Start Relay service
-   */
-  async start () {
-    // Advertise service if HOP enabled
-    if (this.init.hop.enabled !== false && this.init.advertise.enabled !== false) {
-      this.timeout = setDelayedInterval(
-        this._advertiseService, this.init.advertise.ttl, this.init.advertise.bootDelay
-      )
-    }
-
-    this.started = true
-  }
-
-  /**
-   * Stop Relay service
-   */
-  async stop () {
-    if (this.timeout != null) {
-      clearDelayedInterval(this.timeout)
-    }
-
-    this.started = false
-  }
-
-  /**
-   * Advertise hop relay service in the network.
-   */
-  async _advertiseService () {
-    try {
-      const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
-      await this.components.contentRouting.provide(cid)
-    } catch (err: any) {
-      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)
-        // Stop the advertise
-        await this.stop()
-      } else {
-        log.error(err)
-      }
-    }
-  }
-}
+export { circuitRelayServer } from './server/index.js'
+export { circuitRelayTransport } from './transport/index.js'

package/src/circuit/pb/index.proto

@@ -1,42 +1,67 @@
 syntax = "proto3";
 
-message CircuitRelay {
-
-  enum Status {
-    SUCCESS                    = 100;
-    HOP_SRC_ADDR_TOO_LONG      = 220;
-    HOP_DST_ADDR_TOO_LONG      = 221;
-    HOP_SRC_MULTIADDR_INVALID  = 250;
-    HOP_DST_MULTIADDR_INVALID  = 251;
-    HOP_NO_CONN_TO_DST         = 260;
-    HOP_CANT_DIAL_DST          = 261;
-    HOP_CANT_OPEN_DST_STREAM   = 262;
-    HOP_CANT_SPEAK_RELAY       = 270;
-    HOP_CANT_RELAY_TO_SELF     = 280;
-    STOP_SRC_ADDR_TOO_LONG     = 320;
-    STOP_DST_ADDR_TOO_LONG     = 321;
-    STOP_SRC_MULTIADDR_INVALID = 350;
-    STOP_DST_MULTIADDR_INVALID = 351;
-    STOP_RELAY_REFUSED         = 390;
-    MALFORMED_MESSAGE          = 400;
+message HopMessage {
+  enum Type {
+    RESERVE = 0;
+    CONNECT = 1;
+    STATUS = 2;
   }
 
-  enum Type { // RPC identifier, either HOP, STOP or STATUS
-    HOP = 1;
-    STOP = 2;
-    STATUS = 3;
-    CAN_HOP = 4;
-  }
+  // the presence of this field is enforced at application level
+  optional Type type = 1;
+
+  optional Peer peer = 2;
+  optional Reservation reservation = 3;
+  optional Limit limit = 4;
+
+  optional Status status = 5;
+}
 
-  message Peer {
-    required bytes id = 1;    // peer id
-    repeated bytes addrs = 2; // peer's known addresses
+message StopMessage {
+  enum Type {
+    CONNECT = 0;
+    STATUS = 1;
   }
 
-  optional Type type = 1;     // Type of the message
+  // the presence of this field is enforced at application level
+  optional Type type = 1;
+
+  optional Peer peer = 2;
+  optional Limit limit = 3;
+
+  optional Status status = 4;
+}
+
+message Peer {
+  bytes id = 1;
+  repeated bytes addrs = 2;
+}
+
+message Reservation {
+  uint64 expire = 1; // Unix expiration time (UTC)
+  repeated bytes addrs = 2;   // relay addrs for reserving peer
+  optional bytes voucher = 3; // reservation voucher
+}
 
-  optional Peer srcPeer = 2;  // srcPeer and dstPeer are used when Type is HOP or STATUS
-  optional Peer dstPeer = 3;
+message Limit {
+  optional uint32 duration = 1; // seconds
+  optional uint64 data = 2;     // bytes
+}
+
+enum Status {
+  UNUSED = 0;
+  OK                      = 100;
+  RESERVATION_REFUSED     = 200;
+  RESOURCE_LIMIT_EXCEEDED = 201;
+  PERMISSION_DENIED       = 202;
+  CONNECTION_FAILED       = 203;
+  NO_RESERVATION          = 204;
+  MALFORMED_MESSAGE       = 400;
+  UNEXPECTED_MESSAGE      = 401;
+}
 
-  optional Status code = 4;   // Status code, used when Type is STATUS
+message ReservationVoucher {
+  bytes relay = 1;
+  bytes peer = 2;
+  uint64 expiration = 3;
 }