libp2p 0.36.2 → 0.37.0

package/src/config.ts

@@ -0,0 +1,99 @@
+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 { FaultTolerance } 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,
+    autoDial: true,
+    autoDialInterval: 10000,
+    maxParallelDials: Constants.MAX_PARALLEL_DIALS,
+    maxDialsPerPeer: Constants.MAX_PER_PEER_DIALS,
+    dialTimeout: Constants.DIAL_TIMEOUT,
+    resolvers: {
+      dnsaddr: dnsaddrResolver
+    },
+    addressSorter: publicAddressesFirst
+  },
+  connectionGater: {},
+  transportManager: {
+    faultTolerance: FaultTolerance.FATAL_ALL
+  },
+  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/startable'
+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().getConnections().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().getConnections().length < minConnections; i++) {
+      // Connection Manager was stopped during async dial
+      if (!this.running) {
+        return
+      }
+
+      const peer = peers[i]
+
+      if (this.components.getConnectionManager().getConnections(peer.id).length === 0) {
+        log('connecting to a peerStore stored peer %p', peer.id)
+        try {
+          await this.components.getConnectionManager().openConnection(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)
+  }
+}

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

@@ -0,0 +1,59 @@
+import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import { logger } from '@libp2p/logger'
+import type { Components } from '@libp2p/interfaces/components'
+import { TimeoutController } from 'timeout-abort-controller'
+
+const log = logger('libp2p:dialer:auto-dialer')
+
+export interface AutoDialerInit {
+  enabled: boolean
+  minConnections: number
+  dialTimeout: number
+}
+
+export class AutoDialer {
+  private readonly components: Components
+  private readonly enabled: boolean
+  private readonly minConnections: number
+  private readonly dialTimeout: number
+
+  constructor (components: Components, init: AutoDialerInit) {
+    this.components = components
+    this.enabled = init.enabled
+    this.minConnections = init.minConnections
+    this.dialTimeout = init.dialTimeout
+  }
+
+  public handle (evt: CustomEvent<PeerInfo>) {
+    const { detail: peer } = evt
+
+    if (!this.enabled) {
+      return
+    }
+
+    const connections = this.components.getConnectionManager().getConnections(peer.id)
+
+    // If auto dialing is on and we have no connection to the peer, check if we should dial
+    if (connections.length === 0) {
+      const minConnections = this.minConnections ?? 0
+
+      const allConnections = this.components.getConnectionManager().getConnections()
+
+      if (minConnections > allConnections.length) {
+        log('auto-dialing discovered peer %p with timeout %d', peer.id, this.dialTimeout)
+
+        const controller = new TimeoutController(this.dialTimeout)
+
+        void this.components.getConnectionManager().openConnection(peer.id, {
+          signal: controller.signal
+        })
+          .catch(err => {
+            log.error('could not connect to discovered peer %p with %o', peer.id, err)
+          })
+          .finally(() => {
+            controller.clear()
+          })
+      }
+    }
+  }
+}

package/src/{dialer/dial-request.js → connection-manager/dialer/dial-request.ts}

@@ -1,91 +1,102 @@
-'use strict'
-
-const errCode = require('err-code')
-const { anySignal } = require('any-signal')
-// @ts-ignore p-fifo does not export types
-const FIFO = require('p-fifo')
-const pAny = require('p-any')
-// @ts-expect-error setMaxListeners is missing from the types
-const { setMaxListeners } = require('events')
-const { codes } = require('../errors')
-
-/**
- * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- * @typedef {import('./')} Dialer
- * @typedef {import('multiaddr').Multiaddr} Multiaddr
- */
-
-/**
- * @typedef {Object} DialOptions
- * @property {AbortSignal} signal
- *
- * @typedef {Object} DialRequestOptions
- * @property {Multiaddr[]} addrs
- * @property {(m: Multiaddr, options: DialOptions) => Promise<Connection>} dialAction
- * @property {Dialer} dialer
- */
-
-class DialRequest {
+import errCode from 'err-code'
+import { anySignal } from 'any-signal'
+import FIFO from 'p-fifo'
+// @ts-expect-error setMaxListeners is missing from the node 16 types
+import { setMaxListeners } from 'events'
+import { codes } from '../../errors.js'
+import { logger } from '@libp2p/logger'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Connection } from '@libp2p/interfaces/connection'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { Dialer } from './index.js'
+
+const log = logger('libp2p:dialer:dial-request')
+
+export interface DialAction {
+  (m: Multiaddr, options: AbortOptions): Promise<Connection>
+}
+
+export interface DialRequestOptions {
+  addrs: Multiaddr[]
+  dialAction: DialAction
+  dialer: Dialer
+}
+
+export class DialRequest {
+  private readonly addrs: Multiaddr[]
+  private readonly dialer: Dialer
+  private readonly dialAction: DialAction
+
   /**
    * Manages running the `dialAction` on multiple provided `addrs` in parallel
    * up to a maximum determined by the number of tokens returned
    * from `dialer.getTokens`. Once a DialRequest is created, it can be
    * started using `DialRequest.run(options)`. Once a single dial has succeeded,
    * all other dials in the request will be cancelled.
-   *
-   * @class
-   * @param {DialRequestOptions} options
    */
-  constructor ({
-    addrs,
-    dialAction,
-    dialer
-  }) {
+  constructor (options: DialRequestOptions) {
+    const {
+      addrs,
+      dialAction,
+      dialer
+    } = options
+
     this.addrs = addrs
     this.dialer = dialer
     this.dialAction = dialAction
   }
 
-  /**
-   * @async
-   * @param {object} [options]
-   * @param {AbortSignal} [options.signal] - An AbortController signal
-   * @returns {Promise<Connection>}
-   */
-  async run (options = {}) {
+  async run (options: AbortOptions = {}): Promise<Connection> {
     const tokens = this.dialer.getTokens(this.addrs.length)
+
     // If no tokens are available, throw
     if (tokens.length < 1) {
       throw errCode(new Error('No dial tokens available'), codes.ERR_NO_DIAL_TOKENS)
     }
 
-    const tokenHolder = new FIFO()
-    tokens.forEach(token => tokenHolder.push(token))
+    const tokenHolder = new FIFO<number>()
+
+    for (const token of tokens) {
+      void tokenHolder.push(token).catch(err => {
+        log.error(err)
+      })
+    }
+
     const dialAbortControllers = this.addrs.map(() => {
       const controller = new AbortController()
       try {
         // fails on node < 15.4
-        setMaxListeners && setMaxListeners(Infinity, controller.signal)
+        setMaxListeners?.(Infinity, controller.signal)
       } catch {}
 
       return controller
     })
+
+    if (options.signal != null) {
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, options.signal)
+      } catch {}
+    }
+
     let completedDials = 0
 
     try {
-      return await pAny(this.addrs.map(async (addr, i) => {
+      return await Promise.any(this.addrs.map(async (addr, i) => {
         const token = await tokenHolder.shift() // get token
         let conn
         try {
           const signal = dialAbortControllers[i].signal
-          conn = await this.dialAction(addr, { ...options, signal: options.signal ? anySignal([signal, options.signal]) : signal })
+          conn = await this.dialAction(addr, { ...options, signal: (options.signal != null) ? anySignal([signal, options.signal]) : signal })
           // Remove the successful AbortController so it is not aborted
           dialAbortControllers.splice(i, 1)
         } finally {
           completedDials++
           // If we have more or equal dials remaining than tokens, recycle the token, otherwise release it
           if (this.addrs.length - completedDials >= tokens.length) {
-            tokenHolder.push(token)
+            void tokenHolder.push(token).catch(err => {
+              log.error(err)
+            })
           } else {
             this.dialer.releaseToken(tokens.splice(tokens.indexOf(token), 1)[0])
           }
@@ -99,5 +110,3 @@ class DialRequest {
     }
   }
 }
-
-module.exports = DialRequest