libp2p 1.9.4 → 2.0.0-d101aac4b

package/src/connection-manager/reconnect-queue.ts

@@ -0,0 +1,134 @@
+import { KEEP_ALIVE } from '@libp2p/interface'
+import { PeerQueue } from '@libp2p/utils/peer-queue'
+import pRetry from 'p-retry'
+import { MAX_PARALLEL_RECONNECTS } from './constants.js'
+import type { ComponentLogger, Libp2pEvents, Logger, Metrics, Peer, PeerId, PeerStore, Startable, TypedEventTarget } from '@libp2p/interface'
+import type { ConnectionManager } from '@libp2p/interface-internal'
+
+export interface ReconnectQueueComponents {
+  connectionManager: ConnectionManager
+  events: TypedEventTarget<Libp2pEvents>
+  peerStore: PeerStore
+  logger: ComponentLogger
+  metrics?: Metrics
+}
+
+export interface ReconnectQueueInit {
+  retries?: number
+  retryInterval?: number
+  backoffFactor?: number
+  maxParallelReconnects?: number
+}
+
+/**
+ * When peers tagged with `KEEP_ALIVE` disconnect, this component attempts to
+ * redial them
+ */
+export class ReconnectQueue implements Startable {
+  private readonly log: Logger
+  private readonly queue: PeerQueue
+  private started: boolean
+  private readonly peerStore: PeerStore
+  private readonly retries: number
+  private readonly retryInterval?: number
+  private readonly backoffFactor?: number
+  private readonly connectionManager: ConnectionManager
+
+  constructor (components: ReconnectQueueComponents, init: ReconnectQueueInit = {}) {
+    this.log = components.logger.forComponent('libp2p:reconnect-queue')
+    this.peerStore = components.peerStore
+    this.connectionManager = components.connectionManager
+    this.queue = new PeerQueue({
+      concurrency: init.maxParallelReconnects ?? MAX_PARALLEL_RECONNECTS,
+      metricName: 'libp2p_reconnect_queue',
+      metrics: components.metrics
+    })
+    this.started = false
+    this.retries = init.retries ?? 5
+    this.backoffFactor = init.backoffFactor
+    this.retryInterval = init.retryInterval
+
+    components.events.addEventListener('peer:disconnect', (evt) => {
+      this.maybeReconnect(evt.detail)
+        .catch(err => {
+          this.log.error('failed to maybe reconnect to %p', evt.detail, err)
+        })
+    })
+  }
+
+  private async maybeReconnect (peerId: PeerId): Promise<void> {
+    if (!this.started) {
+      return
+    }
+
+    const peer = await this.peerStore.get(peerId)
+
+    if (!peer.tags.has(KEEP_ALIVE)) {
+      return
+    }
+
+    if (this.queue.has(peerId)) {
+      return
+    }
+
+    this.queue.add(async (options) => {
+      await pRetry(async (attempt) => {
+        if (!this.started) {
+          return
+        }
+
+        try {
+          await this.connectionManager.openConnection(peerId, {
+            signal: options?.signal
+          })
+        } catch (err) {
+          this.log('reconnecting to %p attempt %d of %d failed', peerId, attempt, this.retries, err)
+          throw err
+        }
+      }, {
+        signal: options?.signal,
+        retries: this.retries,
+        factor: this.backoffFactor,
+        minTimeout: this.retryInterval
+      })
+    }, {
+      peerId
+    })
+      .catch(err => {
+        this.log.error('failed to reconnect to %p', peerId, err)
+      })
+  }
+
+  start (): void {
+    this.started = true
+  }
+
+  async afterStart (): Promise<void> {
+    // re-connect to any peers with the KEEP_ALIVE tag
+    void Promise.resolve()
+      .then(async () => {
+        const keepAlivePeers: Peer[] = await this.peerStore.all({
+          filters: [(peer) => {
+            return peer.tags.has(KEEP_ALIVE)
+          }]
+        })
+
+        await Promise.all(
+          keepAlivePeers.map(async peer => {
+            await this.connectionManager.openConnection(peer.id)
+              .catch(err => {
+                this.log.error(err)
+              })
+          })
+        )
+      })
+      .catch(err => {
+        this.log.error(err)
+      })
+  }
+
+  stop (): void {
+    this.started = false
+    this.queue.abort()
+  }
+}

package/src/connection-monitor.ts

@@ -1,5 +1,5 @@
 import { randomBytes } from '@libp2p/crypto'
-import { serviceCapabilities } from '@libp2p/interface'
+import { serviceCapabilities, setMaxListeners } from '@libp2p/interface'
 import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
 import { byteStream } from 'it-byte-stream'
 import type { ComponentLogger, Logger, Metrics, Startable } from '@libp2p/interface'
@@ -11,6 +11,7 @@ const PROTOCOL_VERSION = '1.0.0'
 const PROTOCOL_NAME = 'ping'
 const PROTOCOL_PREFIX = 'ipfs'
 const PING_LENGTH = 32
+const DEFAULT_ABORT_CONNECTION_ON_PING_FAILURE = true
 
 export interface ConnectionMonitorInit {
   /**
@@ -65,6 +66,7 @@ export class ConnectionMonitor implements Startable {
   private readonly pingIntervalMs: number
   private abortController?: AbortController
   private readonly timeout: AdaptiveTimeout
+  private readonly abortConnectionOnPingFailure: boolean
 
   constructor (components: ConnectionMonitorComponents, init: ConnectionMonitorInit = {}) {
     this.components = components
@@ -72,7 +74,7 @@ export class ConnectionMonitor implements Startable {
 
     this.log = components.logger.forComponent('libp2p:connection-monitor')
     this.pingIntervalMs = init.pingInterval ?? DEFAULT_PING_INTERVAL_MS
-
+    this.abortConnectionOnPingFailure = init.abortConnectionOnPingFailure ?? DEFAULT_ABORT_CONNECTION_ON_PING_FAILURE
     this.timeout = new AdaptiveTimeout({
       ...(init.pingTimeout ?? {}),
       metrics: components.metrics,
@@ -88,6 +90,7 @@ export class ConnectionMonitor implements Startable {
 
   start (): void {
     this.abortController = new AbortController()
+    setMaxListeners(Infinity, this.abortController.signal)
 
     this.heartbeatInterval = setInterval(() => {
       this.components.connectionManager.getConnections().forEach(conn => {
@@ -99,7 +102,7 @@ export class ConnectionMonitor implements Startable {
             })
             const stream = await conn.newStream(this.protocol, {
               signal,
-              runOnTransientConnection: true
+              runOnLimitedConnection: true
             })
             const bs = byteStream(stream)
             start = Date.now()
@@ -119,7 +122,7 @@ export class ConnectionMonitor implements Startable {
               signal
             })
           } catch (err: any) {
-            if (err.code !== 'ERR_UNSUPPORTED_PROTOCOL') {
+            if (err.name !== 'UnsupportedProtocolError') {
               throw err
             }
 
@@ -131,8 +134,14 @@ export class ConnectionMonitor implements Startable {
           }
         })
           .catch(err => {
-            this.log.error('error during heartbeat, aborting connection', err)
-            conn.abort(err)
+            this.log.error('error during heartbeat', err)
+
+            if (this.abortConnectionOnPingFailure) {
+              this.log.error('aborting connection due to ping failure')
+              conn.abort(err)
+            } else {
+              this.log('connection ping failed, but not aborting due to abortConnectionOnPingFailure flag')
+            }
           })
       })
     }, this.pingIntervalMs)

package/src/content-routing.ts

@@ -1,7 +1,7 @@
-import { CodeError } from '@libp2p/interface'
+import { NotStartedError } from '@libp2p/interface'
 import { PeerSet } from '@libp2p/peer-collections'
 import merge from 'it-merge'
-import { codes, messages } from './errors.js'
+import { NoContentRoutersError } from './errors.js'
 import type { AbortOptions, ComponentLogger, ContentRouting, PeerInfo, PeerRouting, PeerStore, RoutingOptions, Startable } from '@libp2p/interface'
 import type { CID } from 'multiformats/cid'
 
@@ -45,7 +45,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    */
   async * findProviders (key: CID, options: RoutingOptions = {}): AsyncIterable<PeerInfo> {
     if (this.routers.length === 0) {
-      throw new CodeError('No content routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new NoContentRoutersError('No content routers available')
     }
 
     const self = this
@@ -84,7 +84,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    */
   async provide (key: CID, options: AbortOptions = {}): Promise<void> {
     if (this.routers.length === 0) {
-      throw new CodeError('No content routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new NoContentRoutersError('No content routers available')
     }
 
     await Promise.all(this.routers.map(async (router) => {
@@ -97,7 +97,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    */
   async put (key: Uint8Array, value: Uint8Array, options?: AbortOptions): Promise<void> {
     if (!this.isStarted()) {
-      throw new CodeError(messages.NOT_STARTED_YET, codes.ERR_NODE_NOT_STARTED)
+      throw new NotStartedError()
     }
 
     await Promise.all(this.routers.map(async (router) => {
@@ -111,7 +111,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    */
   async get (key: Uint8Array, options?: AbortOptions): Promise<Uint8Array> {
     if (!this.isStarted()) {
-      throw new CodeError(messages.NOT_STARTED_YET, codes.ERR_NODE_NOT_STARTED)
+      throw new NotStartedError()
     }
 
     return Promise.any(this.routers.map(async (router) => {

package/src/errors.ts

@@ -1,67 +1,102 @@
 export enum messages {
   NOT_STARTED_YET = 'The libp2p node is not started yet',
-  ERR_PROTECTOR_REQUIRED = 'Private network is enforced, but no protector was provided',
   NOT_FOUND = 'Not found'
 }
 
-export enum codes {
-  ERR_PROTECTOR_REQUIRED = 'ERR_PROTECTOR_REQUIRED',
-  ERR_PEER_DIAL_INTERCEPTED = 'ERR_PEER_DIAL_INTERCEPTED',
-  ERR_CONNECTION_INTERCEPTED = 'ERR_CONNECTION_INTERCEPTED',
-  ERR_INVALID_PROTOCOLS_FOR_STREAM = 'ERR_INVALID_PROTOCOLS_FOR_STREAM',
-  ERR_CONNECTION_ENDED = 'ERR_CONNECTION_ENDED',
-  ERR_CONNECTION_FAILED = 'ERR_CONNECTION_FAILED',
-  ERR_NODE_NOT_STARTED = 'ERR_NODE_NOT_STARTED',
-  ERR_ALREADY_ABORTED = 'ERR_ALREADY_ABORTED',
-  ERR_TOO_MANY_ADDRESSES = 'ERR_TOO_MANY_ADDRESSES',
-  ERR_NO_VALID_ADDRESSES = 'ERR_NO_VALID_ADDRESSES',
-  ERR_RELAYED_DIAL = 'ERR_RELAYED_DIAL',
-  ERR_DIALED_SELF = 'ERR_DIALED_SELF',
-  ERR_DISCOVERED_SELF = 'ERR_DISCOVERED_SELF',
-  ERR_DUPLICATE_TRANSPORT = 'ERR_DUPLICATE_TRANSPORT',
-  ERR_ENCRYPTION_FAILED = 'ERR_ENCRYPTION_FAILED',
-  ERR_HOP_REQUEST_FAILED = 'ERR_HOP_REQUEST_FAILED',
-  ERR_INVALID_KEY = 'ERR_INVALID_KEY',
-  ERR_INVALID_MESSAGE = 'ERR_INVALID_MESSAGE',
-  ERR_INVALID_PARAMETERS = 'ERR_INVALID_PARAMETERS',
-  ERR_INVALID_PEER = 'ERR_INVALID_PEER',
-  ERR_MUXER_UNAVAILABLE = 'ERR_MUXER_UNAVAILABLE',
-  ERR_NOT_FOUND = 'ERR_NOT_FOUND',
-  ERR_TRANSPORT_UNAVAILABLE = 'ERR_TRANSPORT_UNAVAILABLE',
-  ERR_TRANSPORT_DIAL_FAILED = 'ERR_TRANSPORT_DIAL_FAILED',
-  ERR_UNSUPPORTED_PROTOCOL = 'ERR_UNSUPPORTED_PROTOCOL',
-  ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED = 'ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED',
-  ERR_INVALID_MULTIADDR = 'ERR_INVALID_MULTIADDR',
-  ERR_SIGNATURE_NOT_VALID = 'ERR_SIGNATURE_NOT_VALID',
-  ERR_FIND_SELF = 'ERR_FIND_SELF',
-  ERR_NO_ROUTERS_AVAILABLE = 'ERR_NO_ROUTERS_AVAILABLE',
-  ERR_CONNECTION_NOT_MULTIPLEXED = 'ERR_CONNECTION_NOT_MULTIPLEXED',
-  ERR_NO_DIAL_TOKENS = 'ERR_NO_DIAL_TOKENS',
-  ERR_INVALID_CMS = 'ERR_INVALID_CMS',
-  ERR_MISSING_KEYS = 'ERR_MISSING_KEYS',
-  ERR_NO_KEY = 'ERR_NO_KEY',
-  ERR_INVALID_KEY_NAME = 'ERR_INVALID_KEY_NAME',
-  ERR_INVALID_KEY_TYPE = 'ERR_INVALID_KEY_TYPE',
-  ERR_KEY_ALREADY_EXISTS = 'ERR_KEY_ALREADY_EXISTS',
-  ERR_INVALID_KEY_SIZE = 'ERR_INVALID_KEY_SIZE',
-  ERR_KEY_NOT_FOUND = 'ERR_KEY_NOT_FOUND',
-  ERR_OLD_KEY_NAME_INVALID = 'ERR_OLD_KEY_NAME_INVALID',
-  ERR_NEW_KEY_NAME_INVALID = 'ERR_NEW_KEY_NAME_INVALID',
-  ERR_PASSWORD_REQUIRED = 'ERR_PASSWORD_REQUIRED',
-  ERR_PEM_REQUIRED = 'ERR_PEM_REQUIRED',
-  ERR_CANNOT_READ_KEY = 'ERR_CANNOT_READ_KEY',
-  ERR_MISSING_PRIVATE_KEY = 'ERR_MISSING_PRIVATE_KEY',
-  ERR_MISSING_PUBLIC_KEY = 'ERR_MISSING_PUBLIC_KEY',
-  ERR_INVALID_OLD_PASS_TYPE = 'ERR_INVALID_OLD_PASS_TYPE',
-  ERR_INVALID_NEW_PASS_TYPE = 'ERR_INVALID_NEW_PASS_TYPE',
-  ERR_INVALID_PASS_LENGTH = 'ERR_INVALID_PASS_LENGTH',
-  ERR_NOT_IMPLEMENTED = 'ERR_NOT_IMPLEMENTED',
-  ERR_WRONG_PING_ACK = 'ERR_WRONG_PING_ACK',
-  ERR_INVALID_RECORD = 'ERR_INVALID_RECORD',
-  ERR_ALREADY_SUCCEEDED = 'ERR_ALREADY_SUCCEEDED',
-  ERR_NO_HANDLER_FOR_PROTOCOL = 'ERR_NO_HANDLER_FOR_PROTOCOL',
-  ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS = 'ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS',
-  ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS = 'ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS',
-  ERR_CONNECTION_DENIED = 'ERR_CONNECTION_DENIED',
-  ERR_TRANSFER_LIMIT_EXCEEDED = 'ERR_TRANSFER_LIMIT_EXCEEDED'
+export class MissingServiceError extends Error {
+  constructor (message = 'Missing service') {
+    super(message)
+    this.name = 'MissingServiceError'
+  }
+}
+
+export class UnmetServiceDependenciesError extends Error {
+  constructor (message = 'Unmet service dependencies') {
+    super(message)
+    this.name = 'UnmetServiceDependenciesError'
+  }
+}
+
+export class NoContentRoutersError extends Error {
+  constructor (message = 'No content routers available') {
+    super(message)
+    this.name = 'NoContentRoutersError'
+  }
+}
+
+export class NoPeerRoutersError extends Error {
+  constructor (message = 'No peer routers available') {
+    super(message)
+    this.name = 'NoPeerRoutersError'
+  }
+}
+
+export class QueriedForSelfError extends Error {
+  constructor (message = 'Should not try to find self') {
+    super(message)
+    this.name = 'QueriedForSelfError'
+  }
+}
+
+export class UnhandledProtocolError extends Error {
+  constructor (message = 'Unhandled protocol error') {
+    super(message)
+    this.name = 'UnhandledProtocolError'
+  }
+}
+
+export class DuplicateProtocolHandlerError extends Error {
+  constructor (message = 'Duplicate protocol handler error') {
+    super(message)
+    this.name = 'DuplicateProtocolHandlerError'
+  }
+}
+
+export class DialDeniedError extends Error {
+  constructor (message = 'Dial denied error') {
+    super(message)
+    this.name = 'DialDeniedError'
+  }
+}
+
+export class NoValidAddressesError extends Error {
+  constructor (message = 'No valid addresses') {
+    super(message)
+    this.name = 'NoValidAddressesError'
+  }
+}
+
+export class ConnectionInterceptedError extends Error {
+  constructor (message = 'Connection intercepted') {
+    super(message)
+    this.name = 'ConnectionInterceptedError'
+  }
+}
+
+export class ConnectionDeniedError extends Error {
+  constructor (message = 'Connection denied') {
+    super(message)
+    this.name = 'ConnectionDeniedError'
+  }
+}
+
+export class MuxerUnavailableError extends Error {
+  constructor (message = 'Stream is not multiplexed') {
+    super(message)
+    this.name = 'MuxerUnavailableError'
+  }
+}
+
+export class EncryptionFailedError extends Error {
+  constructor (message = 'Encryption failed') {
+    super(message)
+    this.name = 'EncryptionFailedError'
+  }
+}
+
+export class TransportUnavailableError extends Error {
+  constructor (message = 'Transport unavailable') {
+    super(message)
+    this.name = 'TransportUnavailableError'
+  }
 }

package/src/get-peer.ts

@@ -1,7 +1,6 @@
-import { CodeError, isPeerId } from '@libp2p/interface'
+import { InvalidMultiaddrError, InvalidParametersError, isPeerId } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { isMultiaddr } from '@multiformats/multiaddr'
-import { codes } from './errors.js'
 import type { PeerId } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -31,20 +30,20 @@ export function getPeerAddress (peer: PeerId | Multiaddr | Multiaddr[]): PeerAdd
     // ensure PeerId is either not set or is consistent
     peer.forEach(ma => {
       if (!isMultiaddr(ma)) {
-        throw new CodeError('Invalid Multiaddr', codes.ERR_INVALID_MULTIADDR)
+        throw new InvalidMultiaddrError('Invalid multiaddr')
       }
 
       const maPeerIdStr = ma.getPeerId()
 
       if (maPeerIdStr == null) {
         if (peerId != null) {
-          throw new CodeError('Multiaddrs must all have the same peer id or have no peer id', codes.ERR_INVALID_PARAMETERS)
+          throw new InvalidParametersError('Multiaddrs must all have the same peer id or have no peer id')
         }
       } else {
         const maPeerId = peerIdFromString(maPeerIdStr)
 
         if (peerId?.equals(maPeerId) !== true) {
-          throw new CodeError('Multiaddrs must all have the same peer id or have no peer id', codes.ERR_INVALID_PARAMETERS)
+          throw new InvalidParametersError('Multiaddrs must all have the same peer id or have no peer id')
         }
       }
     })

package/src/index.ts

@@ -14,13 +14,16 @@
  * ```
  */
 
-import { createLibp2pNode } from './libp2p.js'
+import { generateKeyPair } from '@libp2p/crypto/keys'
+import { peerIdFromPrivateKey } from '@libp2p/peer-id'
+import { validateConfig } from './config.js'
+import { Libp2p as Libp2pClass } from './libp2p.js'
 import type { AddressManagerInit } from './address-manager/index.js'
 import type { Components } from './components.js'
 import type { ConnectionManagerInit } from './connection-manager/index.js'
 import type { ConnectionMonitorInit } from './connection-monitor.js'
 import type { TransportManagerInit } from './transport-manager.js'
-import type { Libp2p, ServiceMap, ComponentLogger, NodeInfo, ConnectionProtector, ConnectionEncrypter, ConnectionGater, ContentRouting, Metrics, PeerDiscovery, PeerId, PeerRouting, StreamMuxerFactory, Transport, PrivateKey } from '@libp2p/interface'
+import type { Libp2p, ServiceMap, ComponentLogger, NodeInfo, ConnectionProtector, ConnectionEncrypter, ConnectionGater, ContentRouting, Metrics, PeerDiscovery, PeerRouting, StreamMuxerFactory, Transport, PrivateKey } from '@libp2p/interface'
 import type { PersistentPeerStoreInit } from '@libp2p/peer-store'
 import type { DNS } from '@multiformats/dns'
 import type { Datastore } from 'interface-datastore'
@@ -34,12 +37,11 @@ export type ServiceFactoryMap<T extends ServiceMap = ServiceMap> = {
  */
 export interface Libp2pInit<T extends ServiceMap = ServiceMap> {
   /**
-   * peerId instance (it will be created if not provided)
-   */
-  peerId?: PeerId
-
-  /**
-   * Private key associated with the peerId
+   * The private key is used in cryptographic operations and the Peer ID derived
+   * from it's corresponding public key is used to identify the node to other
+   * peers on the network.
+   *
+   * If this is not passed a new Ed25519 private key will be generated.
    */
   privateKey?: PrivateKey
 
@@ -86,13 +88,36 @@ export interface Libp2pInit<T extends ServiceMap = ServiceMap> {
   peerStore?: PersistentPeerStoreInit
 
   /**
-   * An array that must include at least 1 compliant transport
+   * Transports are low-level communication channels
    */
   transports?: Array<(components: Components) => Transport>
+
+  /**
+   * Stream muxers allow the creation of many data streams over a single
+   * connection.
+   */
   streamMuxers?: Array<(components: Components) => StreamMuxerFactory>
-  connectionEncryption?: Array<(components: Components) => ConnectionEncrypter>
+
+  /**
+   * Connection encrypters ensure that data sent over connections cannot be
+   * eavesdropped on, and that the remote peer posesses the private key that
+   * corresponds to the public key that it's Peer ID is derived from.
+   */
+  connectionEncrypters?: Array<(components: Components) => ConnectionEncrypter>
+
+  /**
+   * Peer discovery mechanisms allow finding peers on the network
+   */
   peerDiscovery?: Array<(components: Components) => PeerDiscovery>
+
+  /**
+   * Peer routers provide implementations for peer routing queries
+   */
   peerRouters?: Array<(components: Components) => PeerRouting>
+
+  /**
+   * Content routers provide implementations for content routing queries
+   */
   contentRouters?: Array<(components: Components) => ContentRouting>
 
   /**
@@ -162,7 +187,7 @@ export type Libp2pOptions<T extends ServiceMap = ServiceMap> = Libp2pInit<T> & {
  * const options = {
  *   transports: [tcp()],
  *   streamMuxers: [yamux(), mplex()],
- *   connectionEncryption: [noise()]
+ *   connectionEncrypters: [noise()]
  * }
  *
  * // create libp2p
@@ -170,7 +195,12 @@ export type Libp2pOptions<T extends ServiceMap = ServiceMap> = Libp2pInit<T> & {
  * ```
  */
 export async function createLibp2p <T extends ServiceMap = ServiceMap> (options: Libp2pOptions<T> = {}): Promise<Libp2p<T>> {
-  const node = await createLibp2pNode(options)
+  options.privateKey ??= await generateKeyPair('Ed25519')
+
+  const node = new Libp2pClass({
+    ...await validateConfig(options),
+    peerId: peerIdFromPrivateKey(options.privateKey)
+  })
 
   if (options.start !== false) {
     await node.start()