libp2p 0.42.2-593deefe → 0.42.2-5e63ee2d

package/src/circuit/multicodec.ts

@@ -1,3 +0,0 @@
-
-export const RELAY_V2_HOP_CODEC = '/libp2p/circuit/relay/0.2.0/hop'
-export const RELAY_V2_STOP_CODEC = '/libp2p/circuit/relay/0.2.0/stop'

package/src/circuit/relay.ts

@@ -1,87 +0,0 @@
-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 { namespaceToCid } from './utils.js'
-import {
-  RELAY_RENDEZVOUS_NS
-} from './constants.js'
-import type { AddressSorter } from '@libp2p/interface-peer-store'
-import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '../components.js'
-import type { HopConfig, RelayAdvertiseConfig } from './index.js'
-
-const log = logger('libp2p:circuit:relay')
-
-export interface RelayInit {
-  addressSorter?: AddressSorter
-  maxListeners?: number
-  hop: HopConfig
-  advertise: RelayAdvertiseConfig
-}
-
-export class Relay implements Startable {
-  private readonly components: Components
-  private readonly init: RelayInit
-  private timeout?: any
-  private started: boolean
-
-  /**
-   * Creates an instance of Relay
-   */
-  constructor (components: Components, init: RelayInit) {
-    this.components = components
-    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 and advertising enabled
-    if (this.init.hop.enabled === true && this.init.advertise.enabled === true) {
-      this.timeout = setDelayedInterval(
-        this._advertiseService, this.init.advertise.ttl, this.init.advertise.bootDelay
-      )
-    }
-
-    this.started = true
-  }
-
-  /**
-   * Stop Relay service
-   */
-  async stop () {
-    try {
-      clearDelayedInterval(this.timeout)
-    } catch (err) { }
-
-    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)
-        await this.stop()
-      } else {
-        log.error('could not advertise service: ', err)
-      }
-    }
-  }
-}

package/src/circuit/reservation-store.ts

@@ -1,106 +0,0 @@
-import { Limit, Status } from './pb/index.js'
-import type { ReservationStore as IReservationStore, ReservationStatus, Reservation } from './interfaces.js'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Startable } from '@libp2p/interfaces/startable'
-import { PeerMap } from '@libp2p/peer-collections'
-import type { RecursivePartial } from '@libp2p/interfaces'
-import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT } from './constants.js'
-
-export interface ReservationStoreInit {
-  /*
-   * maximum number of reservations allowed, default: 15
-   */
-  maxReservations: number
-  /*
-   * interval after which stale reservations are cleared, default: 300s
-   */
-  reservationClearInterval: number
-  /*
-   * apply default relay limits to a new reservation, default: true
-   */
-  applyDefaultLimit: boolean
-  /**
-   * reservation ttl, default: 2 hours
-   */
-  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 type ReservationStoreOptions = RecursivePartial<ReservationStoreInit>
-
-export class ReservationStore implements IReservationStore, Startable {
-  private readonly reservations = new PeerMap<Reservation>()
-  private _started = false;
-  private interval: any
-  private readonly init: ReservationStoreInit
-
-  constructor (options?: ReservationStoreOptions) {
-    this.init = {
-      maxReservations: options?.maxReservations ?? 15,
-      reservationClearInterval: options?.reservationClearInterval ?? 300 * 1000,
-      applyDefaultLimit: options?.applyDefaultLimit !== false,
-      reservationTtl: options?.reservationTtl ?? 2 * 60 * 60 * 1000,
-      defaultDurationLimit: options?.defaultDurationLimit ?? DEFAULT_DURATION_LIMIT,
-      defaultDataLimit: options?.defaultDataLimit ?? DEFAULT_DATA_LIMIT
-    }
-  }
-
-  isStarted () {
-    return this._started
-  }
-
-  start () {
-    if (this._started) {
-      return
-    }
-    this._started = true
-    this.interval = setInterval(
-      () => {
-        const now = (new Date()).getTime()
-        this.reservations.forEach((r, k) => {
-          if (r.expire.getTime() < now) {
-            this.reservations.delete(k)
-          }
-        })
-      },
-      this.init.reservationClearInterval
-    )
-  }
-
-  stop () {
-    clearInterval(this.interval)
-  }
-
-  reserve (peer: PeerId, addr: Multiaddr, limit?: Limit): { status: ReservationStatus, expire?: number } {
-    if (this.reservations.size >= this.init.maxReservations && !this.reservations.has(peer)) {
-      return { status: Status.RESERVATION_REFUSED }
-    }
-    const expire = new Date(Date.now() + this.init.reservationTtl)
-    let checkedLimit: Limit | undefined
-    if (this.init.applyDefaultLimit) {
-      checkedLimit = limit ?? { data: this.init.defaultDataLimit, duration: this.init.defaultDurationLimit }
-    }
-    this.reservations.set(peer, { addr, expire, limit: checkedLimit })
-    return { status: Status.OK, expire: expire.getTime() }
-  }
-
-  removeReservation (peer: PeerId): void {
-    this.reservations.delete(peer)
-  }
-
-  hasReservation (dst: PeerId): boolean {
-    return this.reservations.has(dst)
-  }
-
-  get (peer: PeerId): Reservation | undefined {
-    return this.reservations.get(peer)
-  }
-}

package/src/circuit/stop.ts

@@ -1,92 +0,0 @@
-
-import { Status, StopMessage } from './pb/index.js'
-import type { Connection, Stream } from '@libp2p/interface-connection'
-
-import { logger } from '@libp2p/logger'
-import { RELAY_V2_STOP_CODEC } from './multicodec.js'
-import { multiaddr } from '@multiformats/multiaddr'
-import { pbStream, ProtobufStream } from 'it-pb-stream'
-
-const log = logger('libp2p:circuit:v2:stop')
-
-export interface HandleStopOptions {
-  connection: Connection
-  request: StopMessage
-  pbstr: ProtobufStream<Stream>
-}
-
-const isValidStop = (request: StopMessage): boolean => {
-  if (request.peer == null) {
-    return false
-  }
-  try {
-    request.peer.addrs.forEach(multiaddr)
-  } catch (_err) {
-    return false
-  }
-  return true
-}
-export async function handleStop ({
-  connection,
-  request,
-  pbstr
-}: HandleStopOptions) {
-  const stopstr = pbstr.pb(StopMessage)
-  log('new circuit relay v2 stop stream from %s', connection.remotePeer)
-  // Validate the STOP request has the required input
-  if (request.type !== StopMessage.Type.CONNECT) {
-    log.error('invalid stop connect request via peer %s', connection.remotePeer)
-    stopstr.write({ type: StopMessage.Type.STATUS, status: Status.UNEXPECTED_MESSAGE })
-    return
-  }
-  if (!isValidStop(request)) {
-    log.error('invalid stop connect request via peer %s', connection.remotePeer)
-    stopstr.write({ type: StopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE })
-    return
-  }
-
-  // TODO: go-libp2p marks connection transient if there is limit field present in request.
-  // Cannot find any reference to transient connections in js-libp2p
-
-  stopstr.write({ type: StopMessage.Type.STATUS, status: Status.OK })
-  return pbstr.unwrap()
-}
-
-export interface StopOptions {
-  connection: Connection
-  request: StopMessage
-}
-
-/**
- * Creates a STOP request
- *
- */
-export async function stop ({
-  connection,
-  request
-}: StopOptions): Promise<Stream | undefined> {
-  const stream = await connection.newStream([RELAY_V2_STOP_CODEC])
-  log('starting circuit relay v2 stop request to %s', connection.remotePeer)
-  const pbstr = pbStream(stream)
-  const stopstr = pbstr.pb(StopMessage)
-  stopstr.write(request)
-  let response
-  try {
-    response = await stopstr.read()
-  } catch (err) {
-    log.error('error parsing stop message response from %s', connection.remotePeer)
-  }
-
-  if (response == null) {
-    log.error('could not read response from %s', connection.remotePeer)
-    stream.close()
-    return
-  }
-  if (response.status === Status.OK) {
-    log('stop request to %s was successful', connection.remotePeer)
-    return pbstr.unwrap()
-  }
-
-  log('stop request failed with code %d', response.status)
-  stream.close()
-}

package/src/circuit/transport.ts

@@ -1,313 +0,0 @@
-import * as CircuitV2 from './pb/index.js'
-import { ReservationStore } from './reservation-store.js'
-import { logger } from '@libp2p/logger'
-import createError from 'err-code'
-import * as mafmt from '@multiformats/mafmt'
-import { multiaddr } from '@multiformats/multiaddr'
-import { codes } from '../errors.js'
-import { streamToMaConnection } from '@libp2p/utils/stream-to-ma-conn'
-import { RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from './multicodec.js'
-import { createListener } from './listener.js'
-import { symbol, TransportManager, Upgrader } from '@libp2p/interface-transport'
-import { peerIdFromString } from '@libp2p/peer-id'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { Listener, Transport, CreateListenerOptions, ConnectionHandler } from '@libp2p/interface-transport'
-import type { Connection, Stream } from '@libp2p/interface-connection'
-import type { RelayConfig } from './index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import { handleHopProtocol } from './hop.js'
-import { handleStop } from './stop.js'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { Startable } from '@libp2p/interfaces/dist/src/startable'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import { pbStream } from 'it-pb-stream'
-import pDefer from 'p-defer'
-
-const log = logger('libp2p:circuit')
-
-export interface CircuitOptions {
-  limit?: number
-}
-
-export interface CircuitComponents {
-  peerId: PeerId
-  peerStore: PeerStore
-  registrar: Registrar
-  connectionManager: ConnectionManager
-  upgrader: Upgrader
-  addressManager: AddressManager
-  transportManager: TransportManager
-}
-
-interface ConnectOptions {
-  stream: Stream
-  connection: Connection
-  destinationPeer: PeerId
-  destinationAddr: Multiaddr
-  relayAddr: Multiaddr
-  ma: Multiaddr
-  disconnectOnFailure: boolean
-}
-
-export class Circuit implements Transport, Startable {
-  private handler?: ConnectionHandler
-  private readonly components: CircuitComponents
-  private readonly reservationStore: ReservationStore
-  private readonly _init: RelayConfig
-  private _started: boolean
-
-  constructor (components: CircuitComponents, options: RelayConfig) {
-    this.components = components
-    this._init = options
-    this.reservationStore = new ReservationStore({
-      defaultDataLimit: options.hop?.limit?.data,
-      defaultDurationLimit: options.hop?.limit?.duration
-    })
-    this._started = false
-  }
-
-  isStarted () {
-    return this._started
-  }
-
-  async start (): Promise<void> {
-    if (this._started) {
-      return
-    }
-
-    this._started = true
-
-    // only handle hop if enabled
-    if (this._init.hop.enabled === true) {
-      void this.components.registrar.handle(RELAY_V2_HOP_CODEC, (data) => {
-        void this.onHop(data).catch(err => {
-          log.error(err)
-        })
-      })
-        .catch(err => {
-          log.error(err)
-        })
-    }
-
-    void this.components.registrar.handle(RELAY_V2_STOP_CODEC, (data) => {
-      void this.onStop(data).catch(err => {
-        log.error(err)
-      })
-    })
-      .catch(err => {
-        log.error(err)
-      })
-
-    if (this._init.hop.enabled === true) {
-      void this.reservationStore.start()
-    }
-  }
-
-  async stop () {
-    if (this._init.hop.enabled === true) {
-      this.reservationStore.stop()
-      await this.components.registrar.unhandle(RELAY_V2_HOP_CODEC)
-    }
-    await this.components.registrar.unhandle(RELAY_V2_STOP_CODEC)
-  }
-
-  get [symbol] (): true {
-    return true
-  }
-
-  get [Symbol.toStringTag] () {
-    return 'libp2p/circuit-relay-v2'
-  }
-
-  async onHop ({ connection, stream }: IncomingStreamData) {
-    log('received circuit v2 hop protocol stream from %s', connection.remotePeer)
-
-    const hopTimeoutPromise = pDefer()
-    const timeout = setTimeout(() => {
-      hopTimeoutPromise.reject('timed out')
-    }, this._init.hop.timeout)
-    const pbstr = pbStream(stream)
-
-    try {
-      const request: CircuitV2.HopMessage = await Promise.race([
-        pbstr.pb(CircuitV2.HopMessage).read(),
-        hopTimeoutPromise.promise as any
-      ])
-
-      if (request?.type == null) {
-        throw new Error('request was invalid, could not read from stream')
-      }
-
-      await Promise.race([
-        handleHopProtocol({
-          connection,
-          stream: pbstr,
-          connectionManager: this.components.connectionManager,
-          relayPeer: this.components.peerId,
-          relayAddrs: this.components.addressManager.getListenAddrs(),
-          reservationStore: this.reservationStore,
-          peerStore: this.components.peerStore,
-          request
-        }),
-        hopTimeoutPromise.promise
-      ])
-    } catch (_err) {
-      pbstr.pb(CircuitV2.HopMessage).write({
-        type: CircuitV2.HopMessage.Type.STATUS,
-        status: CircuitV2.Status.MALFORMED_MESSAGE
-      })
-      stream.abort(_err as Error)
-    } finally {
-      clearTimeout(timeout)
-    }
-  }
-
-  async onStop ({ connection, stream }: IncomingStreamData) {
-    const pbstr = pbStream(stream)
-    const request = await pbstr.readPB(CircuitV2.StopMessage)
-    log('received circuit v2 stop protocol request from %s', connection.remotePeer)
-    if (request?.type === undefined) {
-      return
-    }
-
-    const mStream = await handleStop({
-      connection,
-      pbstr,
-      request
-    })
-
-    if (mStream != null) {
-      const remoteAddr = multiaddr(request.peer?.addrs?.[0])
-      const localAddr = this.components.transportManager.getAddrs()[0]
-      const maConn = streamToMaConnection({
-        stream: mStream as any,
-        remoteAddr,
-        localAddr
-      })
-      log('new inbound connection %s', maConn.remoteAddr)
-      const conn = await this.components.upgrader.upgradeInbound(maConn)
-      log('%s connection %s upgraded', 'inbound', maConn.remoteAddr)
-      this.handler?.(conn)
-    }
-  }
-
-  /**
-   * Dial a peer over a relay
-   */
-  async dial (ma: Multiaddr, options: AbortOptions = {}): Promise<Connection> {
-    // Check the multiaddr to see if it contains a relay and a destination peer
-    const addrs = ma.toString().split('/p2p-circuit')
-    const relayAddr = multiaddr(addrs[0])
-    const destinationAddr = multiaddr(addrs[addrs.length - 1])
-    const relayId = relayAddr.getPeerId()
-    const destinationId = destinationAddr.getPeerId()
-
-    if (relayId == null || destinationId == null) {
-      const errMsg = 'Circuit relay dial failed as addresses did not have peer id'
-      log.error(errMsg)
-      throw createError(new Error(errMsg), codes.ERR_RELAYED_DIAL)
-    }
-
-    const relayPeer = peerIdFromString(relayId)
-    const destinationPeer = peerIdFromString(destinationId)
-
-    let disconnectOnFailure = false
-    const relayConnections = this.components.connectionManager.getConnections(relayPeer)
-    let relayConnection = relayConnections[0]
-
-    if (relayConnection == null) {
-      await this.components.peerStore.addressBook.add(relayPeer, [relayAddr])
-      relayConnection = await this.components.connectionManager.openConnection(relayPeer, options)
-      disconnectOnFailure = true
-    }
-
-    try {
-      const stream = await relayConnection.newStream([RELAY_V2_HOP_CODEC])
-      return await this.connectV2({
-        stream,
-        connection: relayConnection,
-        destinationPeer,
-        destinationAddr,
-        relayAddr,
-        ma,
-        disconnectOnFailure
-      })
-    } catch (err: any) {
-      log.error('Circuit relay dial failed', err)
-      disconnectOnFailure && await relayConnection.close()
-      throw err
-    }
-  }
-
-  async connectV2 (
-    {
-      stream, connection, destinationPeer,
-      destinationAddr, relayAddr, ma,
-      disconnectOnFailure
-    }: ConnectOptions
-  ) {
-    try {
-      const pbstr = pbStream(stream)
-      const hopstr = pbstr.pb(CircuitV2.HopMessage)
-      hopstr.write({
-        type: CircuitV2.HopMessage.Type.CONNECT,
-        peer: {
-          id: destinationPeer.toBytes(),
-          addrs: [multiaddr(destinationAddr).bytes]
-        }
-      })
-
-      const status = await hopstr.read()
-      if (status.status !== CircuitV2.Status.OK) {
-        throw createError(new Error(`failed to connect via relay with status ${status?.status?.toString() ?? 'undefined'}`), codes.ERR_HOP_REQUEST_FAILED)
-      }
-
-      // TODO: do something with limit and transient connection
-
-      let localAddr = relayAddr
-      localAddr = localAddr.encapsulate(`/p2p-circuit/p2p/${this.components.peerId.toString()}`)
-      const maConn = streamToMaConnection({
-        stream: pbstr.unwrap(),
-        remoteAddr: ma,
-        localAddr
-      })
-      log('new outbound connection %s', maConn.remoteAddr)
-      const conn = await this.components.upgrader.upgradeOutbound(maConn)
-      return conn
-    } catch (err) {
-      log.error('Circuit relay dial failed', err)
-      disconnectOnFailure && await connection.close()
-      throw err
-    }
-  }
-
-  /**
-   * Create a listener
-   */
-  createListener (options: CreateListenerOptions): Listener {
-    // Called on successful HOP and STOP requests
-    this.handler = options.handler
-
-    return createListener({
-      connectionManager: this.components.connectionManager,
-      peerStore: this.components.peerStore
-    })
-  }
-
-  /**
-   * Filter check for all Multiaddrs that this transport can dial on
-   *
-   * @param {Multiaddr[]} multiaddrs
-   * @returns {Multiaddr[]}
-   */
-  filter (multiaddrs: Multiaddr[]): Multiaddr[] {
-    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
-
-    return multiaddrs.filter((ma) => {
-      return mafmt.Circuit.matches(ma)
-    })
-  }
-}