libp2p 0.36.0 → 0.36.2-199395d

package/src/circuit/transport.ts

@@ -0,0 +1,216 @@
+import { logger } from '@libp2p/logger'
+import errCode from 'err-code'
+import * as mafmt from '@multiformats/mafmt'
+import { Multiaddr } from '@multiformats/multiaddr'
+import { CircuitRelay as CircuitPB } from './pb/index.js'
+import { codes } from '../errors.js'
+import { streamToMaConnection } from '@libp2p/utils/stream-to-ma-conn'
+import { RELAY_CODEC } from './multicodec.js'
+import { createListener } from './listener.js'
+import { handleCanHop, handleHop, hop } from './circuit/hop.js'
+import { handleStop } from './circuit/stop.js'
+import { StreamHandler } from './circuit/stream-handler.js'
+import { symbol } from '@libp2p/interfaces/transport'
+import { peerIdFromString } from '@libp2p/peer-id'
+import { Components, Initializable } from '@libp2p/interfaces/components'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
+import type { Listener, Transport, CreateListenerOptions, ConnectionHandler } from '@libp2p/interfaces/transport'
+import type { Connection } from '@libp2p/interfaces/connection'
+
+const log = logger('libp2p:circuit')
+
+export class Circuit implements Transport, Initializable {
+  private handler?: ConnectionHandler
+  private components: Components = new Components()
+
+  init (components: Components): void {
+    this.components = components
+    void this.components.getRegistrar().handle(RELAY_CODEC, (data) => {
+      void this._onProtocol(data).catch(err => {
+        log.error(err)
+      })
+    })
+      .catch(err => {
+        log.error(err)
+      })
+  }
+
+  hopEnabled () {
+    return true
+  }
+
+  hopActive () {
+    return true
+  }
+
+  get [symbol] (): true {
+    return true
+  }
+
+  get [Symbol.toStringTag] () {
+    return this.constructor.name
+  }
+
+  async _onProtocol (data: IncomingStreamData) {
+    const { connection, stream } = data
+    const streamHandler = new StreamHandler({ stream })
+    const request = await streamHandler.read()
+
+    if (request == null) {
+      log('request was invalid, could not read from stream')
+      streamHandler.write({
+        type: CircuitPB.Type.STATUS,
+        code: CircuitPB.Status.MALFORMED_MESSAGE
+      })
+      streamHandler.close()
+      return
+    }
+
+    let virtualConnection
+
+    switch (request.type) {
+      case CircuitPB.Type.CAN_HOP: {
+        log('received CAN_HOP request from %p', connection.remotePeer)
+        await handleCanHop({ circuit: this, connection, streamHandler })
+        break
+      }
+      case CircuitPB.Type.HOP: {
+        log('received HOP request from %p', connection.remotePeer)
+        virtualConnection = await handleHop({
+          connection,
+          request,
+          streamHandler,
+          circuit: this,
+          connectionManager: this.components.getConnectionManager()
+        })
+        break
+      }
+      case CircuitPB.Type.STOP: {
+        log('received STOP request from %p', connection.remotePeer)
+        virtualConnection = await handleStop({
+          connection,
+          request,
+          streamHandler
+        })
+        break
+      }
+      default: {
+        log('Request of type %s not supported', request.type)
+        streamHandler.write({
+          type: CircuitPB.Type.STATUS,
+          code: CircuitPB.Status.MALFORMED_MESSAGE
+        })
+        streamHandler.close()
+        return
+      }
+    }
+
+    if (virtualConnection != null) {
+      // @ts-expect-error dst peer will not be undefined
+      const remoteAddr = new Multiaddr(request.dstPeer.addrs[0])
+      // @ts-expect-error dst peer will not be undefined
+      const localAddr = new Multiaddr(request.srcPeer.addrs[0])
+      const maConn = streamToMaConnection({
+        stream: virtualConnection,
+        remoteAddr,
+        localAddr
+      })
+      const type = request.type === CircuitPB.Type.HOP ? 'relay' : 'inbound'
+      log('new %s connection %s', type, maConn.remoteAddr)
+
+      const conn = await this.components.getUpgrader().upgradeInbound(maConn)
+      log('%s connection %s upgraded', type, maConn.remoteAddr)
+
+      if (this.handler != null) {
+        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 = new Multiaddr(addrs[0])
+    const destinationAddr = new 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 errCode(new Error(errMsg), codes.ERR_RELAYED_DIAL)
+    }
+
+    const relayPeer = peerIdFromString(relayId)
+    const destinationPeer = peerIdFromString(destinationId)
+
+    let disconnectOnFailure = false
+    let relayConnection = this.components.getConnectionManager().getConnection(relayPeer)
+    if (relayConnection == null) {
+      relayConnection = await this.components.getDialer().dial(relayAddr, options)
+      disconnectOnFailure = true
+    }
+
+    try {
+      const virtualConnection = await hop({
+        connection: relayConnection,
+        request: {
+          type: CircuitPB.Type.HOP,
+          srcPeer: {
+            id: this.components.getPeerId().toBytes(),
+            addrs: this.components.getAddressManager().getAddresses().map(addr => addr.bytes)
+          },
+          dstPeer: {
+            id: destinationPeer.toBytes(),
+            addrs: [new Multiaddr(destinationAddr).bytes]
+          }
+        }
+      })
+
+      const localAddr = relayAddr.encapsulate(`/p2p-circuit/p2p/${this.components.getPeerId().toString()}`)
+      const maConn = streamToMaConnection({
+        stream: virtualConnection,
+        remoteAddr: ma,
+        localAddr
+      })
+      log('new outbound connection %s', maConn.remoteAddr)
+
+      return await this.components.getUpgrader().upgradeOutbound(maConn)
+    } catch (err: any) {
+      log.error('Circuit relay dial failed', err)
+      disconnectOnFailure && await relayConnection.close()
+      throw err
+    }
+  }
+
+  /**
+   * Create a listener
+   */
+  createListener (options: CreateListenerOptions): Listener {
+    // Called on successful HOP and STOP requests
+    this.handler = options.handler
+
+    return createListener({
+      dialer: this.components.getDialer(),
+      connectionManager: this.components.getConnectionManager()
+    })
+  }
+
+  /**
+   * 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)
+    })
+  }
+}

package/src/circuit/utils.ts

@@ -0,0 +1,12 @@
+import { CID } from 'multiformats/cid'
+import { sha256 } from 'multiformats/hashes/sha2'
+
+/**
+ * Convert a namespace string into a cid
+ */
+export async function namespaceToCid (namespace: string): Promise<CID> {
+  const bytes = new TextEncoder().encode(namespace)
+  const hash = await sha256.digest(bytes)
+
+  return CID.createV0(hash)
+}

package/src/config.ts

@@ -0,0 +1,101 @@
+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 { FAULT_TOLERANCE } from './transport-manager.js'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Libp2pInit } from './index.js'
+import { codes, messages } from './errors.js'
+import errCode from 'err-code'
+import type { RecursivePartial } from '@libp2p/interfaces'
+
+const DefaultConfig: Partial<Libp2pInit> = {
+  addresses: {
+    listen: [],
+    announce: [],
+    noAnnounce: [],
+    announceFilter: (multiaddrs: Multiaddr[]) => multiaddrs
+  },
+  connectionManager: {
+    maxConnections: 300,
+    minConnections: 50,
+    autoDialInterval: 10000,
+    autoDial: true
+  },
+  connectionGater: {},
+  transportManager: {
+    faultTolerance: FAULT_TOLERANCE.FATAL_ALL
+  },
+  dialer: {
+    maxParallelDials: Constants.MAX_PARALLEL_DIALS,
+    maxDialsPerPeer: Constants.MAX_PER_PEER_DIALS,
+    dialTimeout: Constants.DIAL_TIMEOUT,
+    resolvers: {
+      dnsaddr: dnsaddrResolver
+    },
+    addressSorter: publicAddressesFirst
+  },
+  host: {
+    agentVersion: AGENT_VERSION
+  },
+  metrics: {
+    enabled: false,
+    computeThrottleMaxQueueSize: 1000,
+    computeThrottleTimeout: 2000,
+    movingAverageIntervals: [
+      60 * 1000, // 1 minute
+      5 * 60 * 1000, // 5 minutes
+      15 * 60 * 1000 // 15 minutes
+    ],
+    maxOldPeersRetention: 50
+  },
+  peerRouting: {
+    refreshManager: {
+      enabled: true,
+      interval: 6e5,
+      bootDelay: 10e3
+    }
+  },
+  protocolPrefix: 'ipfs',
+  nat: {
+    enabled: true,
+    ttl: 7200,
+    keepAlive: true
+  },
+  relay: {
+    enabled: true,
+    advertise: {
+      bootDelay: RelayConstants.ADVERTISE_BOOT_DELAY,
+      enabled: false,
+      ttl: RelayConstants.ADVERTISE_TTL
+    },
+    hop: {
+      enabled: false,
+      active: false
+    },
+    autoRelay: {
+      enabled: false,
+      maxListeners: 2
+    }
+  }
+}
+
+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)
+  }
+
+  if (resultingOptions.connectionEncryption == null || resultingOptions.connectionEncryption.length === 0) {
+    throw errCode(new Error(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)
+  }
+
+  return resultingOptions
+}

package/src/connection-manager/auto-dialler.ts

@@ -0,0 +1,154 @@
+import { logger } from '@libp2p/logger'
+import mergeOptions from 'merge-options'
+// @ts-expect-error retimer does not have types
+import retimer from 'retimer'
+import all from 'it-all'
+import { pipe } from 'it-pipe'
+import filter from 'it-filter'
+import sort from 'it-sort'
+import type { Startable } from '@libp2p/interfaces'
+import type { Components } from '@libp2p/interfaces/components'
+
+const log = logger('libp2p:connection-manager:auto-dialler')
+
+export interface AutoDiallerInit {
+  /**
+   * Should preemptively guarantee connections are above the low watermark
+   */
+  enabled?: boolean
+
+  /**
+   * The minimum number of connections to avoid pruning
+   */
+  minConnections?: number
+
+  /**
+   * How often, in milliseconds, it should preemptively guarantee connections are above the low watermark
+   */
+  autoDialInterval?: number
+}
+
+const defaultOptions: Partial<AutoDiallerInit> = {
+  enabled: true,
+  minConnections: 0,
+  autoDialInterval: 10000
+}
+
+export class AutoDialler implements Startable {
+  private readonly components: Components
+  private readonly options: Required<AutoDiallerInit>
+  private running: boolean
+  private autoDialTimeout?: ReturnType<retimer>
+
+  /**
+   * Proactively tries to connect to known peers stored in the PeerStore.
+   * It will keep the number of connections below the upper limit and sort
+   * the peers to connect based on wether we know their keys and protocols.
+   */
+  constructor (components: Components, init: AutoDiallerInit) {
+    this.components = components
+    this.options = mergeOptions.call({ ignoreUndefined: true }, defaultOptions, init)
+    this.running = false
+    this._autoDial = this._autoDial.bind(this)
+
+    log('options: %j', this.options)
+  }
+
+  isStarted () {
+    return this.running
+  }
+
+  /**
+   * Starts the auto dialer
+   */
+  async start () {
+    if (!this.options.enabled) {
+      log('not enabled')
+      return
+    }
+
+    this.running = true
+
+    void this._autoDial().catch(err => {
+      log.error('could start autodial', err)
+    })
+
+    log('started')
+  }
+
+  /**
+   * Stops the auto dialler
+   */
+  async stop () {
+    if (!this.options.enabled) {
+      log('not enabled')
+      return
+    }
+
+    this.running = false
+
+    if (this.autoDialTimeout != null) {
+      this.autoDialTimeout.clear()
+    }
+
+    log('stopped')
+  }
+
+  async _autoDial () {
+    if (this.autoDialTimeout != null) {
+      this.autoDialTimeout.clear()
+    }
+
+    const minConnections = this.options.minConnections
+
+    // Already has enough connections
+    if (this.components.getConnectionManager().getConnectionList().length >= minConnections) {
+      this.autoDialTimeout = retimer(this._autoDial, this.options.autoDialInterval)
+
+      return
+    }
+
+    // Sort peers on whether we know protocols or public keys for them
+    const allPeers = await this.components.getPeerStore().all()
+
+    const peers = await pipe(
+      // shuffle the peers
+      allPeers.sort(() => Math.random() > 0.5 ? 1 : -1),
+      (source) => filter(source, (peer) => !peer.id.equals(this.components.getPeerId())),
+      (source) => sort(source, (a, b) => {
+        if (b.protocols.length > a.protocols.length) {
+          return 1
+        } else if (b.id.publicKey != null && a.id.publicKey == null) {
+          return 1
+        }
+        return -1
+      }),
+      async (source) => await all(source)
+    )
+
+    for (let i = 0; this.running && i < peers.length && this.components.getConnectionManager().getConnectionList().length < minConnections; i++) {
+      // Connection Manager was stopped during async dial
+      if (!this.running) {
+        return
+      }
+
+      const peer = peers[i]
+
+      if (this.components.getConnectionManager().getConnection(peer.id) == null) {
+        log('connecting to a peerStore stored peer %p', peer.id)
+        try {
+          await this.components.getDialer().dial(peer.id)
+        } catch (err: any) {
+          log.error('could not connect to peerStore stored peer', err)
+        }
+      }
+    }
+
+    // Connection Manager was stopped
+    if (!this.running) {
+      return
+    }
+
+    this.autoDialTimeout = retimer(this._autoDial, this.options.autoDialInterval)
+  }
+}