libp2p 0.46.21 → 1.0.0

package/src/autonat/pb/index.ts

@@ -1,320 +0,0 @@
-/* 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-relay/constants.ts

@@ -1,72 +0,0 @@
-const second = 1000
-const minute = 60 * second
-
-/**
- * Delay before HOP relay service is advertised on the network
- */
-export const ADVERTISE_BOOT_DELAY = 15 * minute
-
-/**
- * Delay Between HOP relay service advertisements on the network
- */
-export const ADVERTISE_TTL = 30 * minute
-
-/**
- * Multicodec code
- */
-export const CIRCUIT_PROTO_CODE = 290
-
-/**
- * Relay HOP relay service namespace for discovery
- */
-export const RELAY_RENDEZVOUS_NS = '/libp2p/relay'
-
-/**
- * The maximum number of relay reservations the relay server will accept
- */
-export const DEFAULT_MAX_RESERVATION_STORE_SIZE = 15
-
-/**
- * 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 * 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-relay/index.ts

@@ -1,59 +0,0 @@
-/**
- * @packageDocumentation
- *
- * The `circuitRelayTransport` allows libp2p to dial and listen on [Circuit Relay](https://docs.libp2p.io/concepts/nat/circuit-relay/)
- * addresses.
- *
- * @example
- *
- * ```typescript
- * import { createLibp2p } from 'libp2p'
- * import { circuitRelayTransport } from 'libp2p/circuit-relay'
- *
- * const node = await createLibp2p({
- *   transports: [
- *     circuitRelayTransport()
- *   ]
- * })
- * ```
- *
- * The `circuitRelayServer` function allows libp2p to function as a [Circuit Relay](https://docs.libp2p.io/concepts/nat/circuit-relay/)
- * server.  This will not work in browsers.
- *
- * @example
- *
- * ```typescript
- * import { createLibp2p } from 'libp2p'
- * import { circuitRelayServer } from 'libp2p/circuit-relay'
- *
- * const node = await createLibp2p({
- *   services: [
- *     circuitRelay: circuitRelayServer()
- *   ]
- * })
- * ```
- */
-
-import type { Limit } from './pb/index.js'
-import type { TypedEventEmitter } from '@libp2p/interface/events'
-import type { PeerMap } from '@libp2p/peer-collections'
-import type { Multiaddr } from '@multiformats/multiaddr'
-
-export interface RelayReservation {
-  expire: Date
-  addr: Multiaddr
-  limit?: Limit
-}
-
-export interface CircuitRelayServiceEvents {
-  'relay:reservation': CustomEvent<RelayReservation>
-  'relay:advert:success': CustomEvent<unknown>
-  'relay:advert:error': CustomEvent<Error>
-}
-
-export interface CircuitRelayService extends TypedEventEmitter<CircuitRelayServiceEvents> {
-  reservations: PeerMap<RelayReservation>
-}
-
-export { circuitRelayServer } from './server/index.js'
-export { circuitRelayTransport } from './transport/index.js'

package/src/circuit-relay/pb/index.proto

@@ -1,67 +0,0 @@
-syntax = "proto3";
-
-message HopMessage {
-  enum Type {
-    RESERVE = 0;
-    CONNECT = 1;
-    STATUS = 2;
-  }
-
-  // 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 StopMessage {
-  enum Type {
-    CONNECT = 0;
-    STATUS = 1;
-  }
-
-  // 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
-}
-
-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;
-}
-
-message ReservationVoucher {
-  bytes relay = 1;
-  bytes peer = 2;
-  uint64 expiration = 3;
-}