libp2p 0.39.5 → 0.40.0

package/src/connection-manager/index.ts

@@ -11,14 +11,16 @@ import { codes } from '../errors.js'
 import { isPeerId, PeerId } from '@libp2p/interface-peer-id'
 import { setMaxListeners } from 'events'
 import type { Connection, MultiaddrConnection } from '@libp2p/interface-connection'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import { Components, Initializable } from '@libp2p/components'
+import type { ConnectionManager, Dialer } from '@libp2p/interface-connection-manager'
 import * as STATUS from '@libp2p/interface-connection/status'
-import type { AddressSorter } from '@libp2p/interface-peer-store'
-import type { Resolver } from '@multiformats/multiaddr'
+import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
+import { multiaddr, Multiaddr, Resolver } from '@multiformats/multiaddr'
 import { PeerMap } from '@libp2p/peer-collections'
 import { TimeoutController } from 'timeout-abort-controller'
 import { KEEP_ALIVE } from '@libp2p/interface-peer-store/tags'
+import { RateLimiterMemory } from 'rate-limiter-flexible'
+import type { Metrics } from '@libp2p/interface-metrics'
+import type { Upgrader } from '@libp2p/interface-transport'
 
 const log = logger('libp2p:connection-manager')
 
@@ -31,7 +33,9 @@ const defaultOptions: Partial<ConnectionManagerInit> = {
   maxEventLoopDelay: Infinity,
   pollInterval: 2000,
   autoDialInterval: 10000,
-  movingAverageInterval: 60000
+  movingAverageInterval: 60000,
+  inboundConnectionThreshold: 5,
+  maxIncomingPendingConnections: 10
 }
 
 const METRICS_SYSTEM = 'libp2p'
@@ -132,6 +136,30 @@ export interface ConnectionManagerInit {
    * tagged with KEEP_ALIVE up to this timeout in ms. (default: 60000)
    */
   startupReconnectTimeout?: number
+
+  /**
+   * A list of multiaddrs that will always be allowed (except if they are in the
+   * deny list) to open connections to this node even if we've reached maxConnections
+   */
+  allow?: string[]
+
+  /**
+   * A list of multiaddrs that will never be allowed to open connections to
+   * this node under any circumstances
+   */
+  deny?: string[]
+
+  /**
+   * If more than this many connections are opened per second by a single
+   * host, reject subsequent connections
+   */
+  inboundConnectionThreshold?: number
+
+  /**
+   * The maximum number of parallel incoming connections allowed that have yet to
+   * complete the connection upgrade - e.g. choosing connection encryption, muxer, etc
+   */
+  maxIncomingPendingConnections?: number
 }
 
 export interface ConnectionManagerEvents {
@@ -139,11 +167,19 @@ export interface ConnectionManagerEvents {
   'peer:disconnect': CustomEvent<PeerId>
 }
 
+export interface DefaultConnectionManagerComponents {
+  peerId: PeerId
+  metrics?: Metrics
+  upgrader: Upgrader
+  peerStore: PeerStore
+  dialer: Dialer
+}
+
 /**
  * Responsible for managing known connections.
  */
-export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEvents> implements ConnectionManager, Startable, Initializable {
-  private components = new Components()
+export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEvents> implements ConnectionManager, Startable {
+  private readonly components: DefaultConnectionManagerComponents
   private readonly opts: Required<ConnectionManagerInit>
   private readonly connections: Map<string, Connection[]>
   private started: boolean
@@ -152,8 +188,12 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   private readonly startupReconnectTimeout: number
   private connectOnStartupController?: TimeoutController
   private readonly dialTimeout: number
+  private readonly allow: Multiaddr[]
+  private readonly deny: Multiaddr[]
+  private readonly inboundConnectionRateLimiter: RateLimiterMemory
+  private incomingPendingConnections: number
 
-  constructor (init: ConnectionManagerInit) {
+  constructor (components: DefaultConnectionManagerComponents, init: ConnectionManagerInit) {
     super()
 
     this.opts = mergeOptions.call({ ignoreUndefined: true }, defaultOptions, init)
@@ -164,6 +204,8 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
 
     log('options: %o', this.opts)
 
+    this.components = components
+
     /**
      * Map of connections per peer
      */
@@ -187,13 +229,33 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
 
     this.startupReconnectTimeout = init.startupReconnectTimeout ?? STARTUP_RECONNECT_TIMEOUT
     this.dialTimeout = init.dialTimeout ?? 30000
+
+    this.allow = (init.allow ?? []).map(ma => multiaddr(ma))
+    this.deny = (init.deny ?? []).map(ma => multiaddr(ma))
+
+    this.inboundConnectionRateLimiter = new RateLimiterMemory({
+      points: this.opts.inboundConnectionThreshold,
+      duration: 1
+    })
+
+    this.incomingPendingConnections = 0
   }
 
-  init (components: Components): void {
-    this.components = components
+  isStarted () {
+    return this.started
+  }
+
+  /**
+   * Starts the Connection Manager. If Metrics are not enabled on libp2p
+   * only event loop and connection limits will be monitored.
+   */
+  async start () {
+    if (this.components.metrics != null) {
+      this.timer = this.timer ?? retimer(this._checkMetrics, this.opts.pollInterval)
+    }
 
     // track inbound/outbound connections
-    this.components.getMetrics()?.updateComponentMetric({
+    this.components.metrics?.updateComponentMetric({
       system: METRICS_SYSTEM,
       component: METRICS_COMPONENT,
       metric: 'connections',
@@ -219,7 +281,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     })
 
     // track total number of streams per protocol
-    this.components.getMetrics()?.updateComponentMetric({
+    this.components.metrics?.updateComponentMetric({
       system: METRICS_SYSTEM,
       component: METRICS_COMPONENT,
       metric: 'protocol-streams-total',
@@ -242,7 +304,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     })
 
     // track 90th percentile of streams per protocol
-    this.components.getMetrics()?.updateComponentMetric({
+    this.components.metrics?.updateComponentMetric({
       system: METRICS_SYSTEM,
       component: METRICS_COMPONENT,
       metric: 'protocol-streams-per-connection-90th-percentile',
@@ -279,20 +341,6 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
         return metric
       }
     })
-  }
-
-  isStarted () {
-    return this.started
-  }
-
-  /**
-   * Starts the Connection Manager. If Metrics are not enabled on libp2p
-   * only event loop and connection limits will be monitored.
-   */
-  async start () {
-    if (this.components.getMetrics() != null) {
-      this.timer = this.timer ?? retimer(this._checkMetrics, this.opts.pollInterval)
-    }
 
     // latency monitor
     this.latencyMonitor.start()
@@ -304,16 +352,16 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   }
 
   async afterStart () {
-    this.components.getUpgrader().addEventListener('connection', this.onConnect)
-    this.components.getUpgrader().addEventListener('connectionEnd', this.onDisconnect)
+    this.components.upgrader.addEventListener('connection', this.onConnect)
+    this.components.upgrader.addEventListener('connectionEnd', this.onDisconnect)
 
     // re-connect to any peers with the KEEP_ALIVE tag
     void Promise.resolve()
       .then(async () => {
         const keepAlivePeers: PeerId[] = []
 
-        for (const peer of await this.components.getPeerStore().all()) {
-          const tags = await this.components.getPeerStore().getTags(peer.id)
+        for (const peer of await this.components.peerStore.all()) {
+          const tags = await this.components.peerStore.getTags(peer.id)
           const hasKeepAlive = tags.filter(tag => tag.name === KEEP_ALIVE).length > 0
 
           if (hasKeepAlive) {
@@ -351,8 +399,8 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   async beforeStop () {
     // if we are still dialing KEEP_ALIVE peers, abort those dials
     this.connectOnStartupController?.abort()
-    this.components.getUpgrader().removeEventListener('connection', this.onConnect)
-    this.components.getUpgrader().removeEventListener('connectionEnd', this.onDisconnect)
+    this.components.upgrader.removeEventListener('connection', this.onConnect)
+    this.components.upgrader.removeEventListener('connectionEnd', this.onDisconnect)
   }
 
   /**
@@ -399,7 +447,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
    * @private
    */
   async _checkMetrics () {
-    const metrics = this.components.getMetrics()
+    const metrics = this.components.metrics
 
     if (metrics != null) {
       try {
@@ -446,7 +494,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     }
 
     if (peerId.publicKey != null) {
-      await this.components.getPeerStore().keyBook.set(peerId, peerId.publicKey)
+      await this.components.peerStore.keyBook.set(peerId, peerId.publicKey)
     }
 
     const numConnections = this.getConnections().length
@@ -477,7 +525,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
       this.connections.delete(peerId)
       this.dispatchEvent(new CustomEvent<Connection>('peer:disconnect', { detail: connection }))
 
-      this.components.getMetrics()?.onPeerDisconnected(connection.remotePeer)
+      this.components.metrics?.onPeerDisconnected(connection.remotePeer)
     }
   }
 
@@ -518,7 +566,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     }
 
     try {
-      const connection = await this.components.getDialer().dial(peerId, options)
+      const connection = await this.components.dialer.dial(peerId, options)
       let peerConnections = this.connections.get(peerId.toString())
 
       if (peerConnections == null) {
@@ -597,8 +645,8 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     const limit = this.opts[name]
     log.trace('checking limit of %s. current value: %d of %d', name, value, limit)
     if (value > limit) {
-      log('%s: limit exceeded: %p, %d/%d, pruning %d connection(s)', this.components.getPeerId(), name, value, limit, toPrune)
-      await this._maybePruneConnections(toPrune)
+      log('%s: limit exceeded: %p, %d/%d, pruning %d connection(s)', this.components.peerId, name, value, limit, toPrune)
+      await this._pruneConnections(toPrune)
     }
   }
 
@@ -606,13 +654,8 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
    * If we have more connections than our maximum, select some excess connections
    * to prune based on peer value
    */
-  async _maybePruneConnections (toPrune: number) {
+  async _pruneConnections (toPrune: number) {
     const connections = this.getConnections()
-
-    if (connections.length <= this.opts.minConnections || toPrune < 1) {
-      return
-    }
-
     const peerValues = new PeerMap<number>()
 
     // work out peer values
@@ -623,7 +666,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
         continue
       }
 
-      const tags = await this.components.getPeerStore().getTags(remotePeer)
+      const tags = await this.components.peerStore.getTags(remotePeer)
 
       // sum all tag values
       peerValues.set(remotePeer, tags.reduce((acc, curr) => {
@@ -677,6 +720,55 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   }
 
   async acceptIncomingConnection (maConn: MultiaddrConnection): Promise<boolean> {
-    return true
+    // check deny list
+    const denyConnection = this.deny.some(ma => {
+      return maConn.remoteAddr.toString().startsWith(ma.toString())
+    })
+
+    if (denyConnection) {
+      log('connection from %s refused - connection remote address was in deny list', maConn.remoteAddr)
+      return false
+    }
+
+    // check allow list
+    const allowConnection = this.allow.some(ma => {
+      return maConn.remoteAddr.toString().startsWith(ma.toString())
+    })
+
+    if (allowConnection) {
+      this.incomingPendingConnections++
+
+      return true
+    }
+
+    // check pending connections
+    if (this.incomingPendingConnections === this.opts.maxIncomingPendingConnections) {
+      log('connection from %s refused - incomingPendingConnections exceeded by peer %s', maConn.remoteAddr)
+      return false
+    }
+
+    if (maConn.remoteAddr.isThinWaistAddress()) {
+      const host = maConn.remoteAddr.nodeAddress().address
+
+      try {
+        await this.inboundConnectionRateLimiter.consume(host, 1)
+      } catch {
+        log('connection from %s refused - inboundConnectionThreshold exceeded by host %s', host, maConn.remoteAddr)
+        return false
+      }
+    }
+
+    if (this.getConnections().length < this.opts.maxConnections) {
+      this.incomingPendingConnections++
+
+      return true
+    }
+
+    log('connection from %s refused - maxConnections exceeded', maConn.remoteAddr)
+    return false
+  }
+
+  afterUpgradeInbound () {
+    this.incomingPendingConnections--
   }
 }

package/src/content-routing/index.ts

@@ -12,18 +12,24 @@ import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { CID } from 'multiformats/cid'
-import type { Components } from '@libp2p/components'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { DualDHT } from '@libp2p/interface-dht'
 
 export interface CompoundContentRoutingInit {
   routers: ContentRouting[]
 }
 
+export interface CompoundContentRoutingComponents {
+  peerStore: PeerStore
+  dht?: DualDHT
+}
+
 export class CompoundContentRouting implements ContentRouting, Startable {
   private readonly routers: ContentRouting[]
   private started: boolean
-  private readonly components: Components
+  private readonly components: CompoundContentRoutingComponents
 
-  constructor (components: Components, init: CompoundContentRoutingInit) {
+  constructor (components: CompoundContentRoutingComponents, init: CompoundContentRoutingInit) {
     this.routers = init.routers ?? []
     this.started = false
     this.components = components
@@ -53,7 +59,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       merge(
         ...this.routers.map(router => router.findProviders(key, options))
       ),
-      (source) => storeAddresses(source, this.components.getPeerStore()),
+      (source) => storeAddresses(source, this.components.peerStore),
       (source) => uniquePeers(source),
       (source) => requirePeers(source)
     )
@@ -79,7 +85,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
     }
 
-    const dht = this.components.getDHT()
+    const dht = this.components.dht
 
     if (dht != null) {
       await drain(dht.put(key, value, options))
@@ -95,7 +101,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
     }
 
-    const dht = this.components.getDHT()
+    const dht = this.components.dht
 
     if (dht != null) {
       for await (const event of dht.get(key, options)) {
@@ -121,7 +127,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
     }
 
     let gotValues = 0
-    const dht = this.components.getDHT()
+    const dht = this.components.dht
 
     if (dht != null) {
       for await (const event of dht.get(key, options)) {

package/src/errors.ts

@@ -73,5 +73,6 @@ export enum codes {
   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_TOO_MANY_INBOUND_PROTOCOL_STREAMS = 'ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS',
+  ERR_CONNECTION_DENIED = 'ERR_CONNECTION_DENIED'
 }

package/src/fetch/index.ts

@@ -7,14 +7,14 @@ import { PROTOCOL_NAME, PROTOCOL_VERSION } from './constants.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { Stream } from '@libp2p/interface-connection'
-import type { IncomingStreamData } from '@libp2p/interface-registrar'
-import type { Components } from '@libp2p/components'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { abortableDuplex } from 'abortable-iterator'
 import { pipe } from 'it-pipe'
 import first from 'it-first'
 import { TimeoutController } from 'timeout-abort-controller'
 import { setMaxListeners } from 'events'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 
 const log = logger('libp2p:fetch')
 
@@ -38,6 +38,11 @@ export interface LookupFunction {
   (key: string): Promise<Uint8Array | null>
 }
 
+export interface FetchServiceComponents {
+  registrar: Registrar
+  connectionManager: ConnectionManager
+}
+
 /**
  * A simple libp2p protocol for requesting a value corresponding to a key from a peer.
  * Developers can register one or more lookup function for retrieving the value corresponding to
@@ -46,12 +51,12 @@ export interface LookupFunction {
  */
 export class FetchService implements Startable {
   public readonly protocol: string
-  private readonly components: Components
+  private readonly components: FetchServiceComponents
   private readonly lookupFunctions: Map<string, LookupFunction>
   private started: boolean
   private readonly init: FetchServiceInit
 
-  constructor (components: Components, init: FetchServiceInit) {
+  constructor (components: FetchServiceComponents, init: FetchServiceInit) {
     this.started = false
     this.components = components
     this.protocol = `/${init.protocolPrefix ?? 'libp2p'}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
@@ -61,7 +66,7 @@ export class FetchService implements Startable {
   }
 
   async start () {
-    await this.components.getRegistrar().handle(this.protocol, (data) => {
+    await this.components.registrar.handle(this.protocol, (data) => {
       void this.handleMessage(data)
         .catch(err => {
           log.error(err)
@@ -77,7 +82,7 @@ export class FetchService implements Startable {
   }
 
   async stop () {
-    await this.components.getRegistrar().unhandle(this.protocol)
+    await this.components.registrar.unhandle(this.protocol)
     this.started = false
   }
 
@@ -91,7 +96,7 @@ export class FetchService implements Startable {
   async fetch (peer: PeerId, key: string, options: AbortOptions = {}): Promise<Uint8Array | null> {
     log('dialing %s to %p', this.protocol, peer)
 
-    const connection = await this.components.getConnectionManager().openConnection(peer, options)
+    const connection = await this.components.connectionManager.openConnection(peer, options)
     let timeoutController
     let signal = options.signal
     let stream: Stream | undefined

package/src/fetch/pb/proto.ts

@@ -1,5 +1,7 @@
 /* eslint-disable import/export */
+/* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 
 import { encodeMessage, decodeMessage, message, enumeration } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
@@ -14,23 +16,23 @@ export namespace FetchRequest {
 
   export const codec = (): Codec<FetchRequest> => {
     if (_codec == null) {
-      _codec = message<FetchRequest>((obj, writer, opts = {}) => {
+      _codec = message<FetchRequest>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
-        if (obj.identifier != null) {
-          writer.uint32(10)
-          writer.string(obj.identifier)
-        } else {
-          throw new Error('Protocol error: required field "identifier" was not found in object')
+        if (opts.writeDefaults === true || obj.identifier !== '') {
+          w.uint32(10)
+          w.string(obj.identifier)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
-        const obj: any = {}
+        const obj: any = {
+          identifier: ''
+        }
 
         const end = length == null ? reader.len : reader.pos + length
 
@@ -47,10 +49,6 @@ export namespace FetchRequest {
           }
         }
 
-        if (obj.identifier == null) {
-          throw new Error('Protocol error: value for required field "identifier" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -95,30 +93,29 @@ export namespace FetchResponse {
 
   export const codec = (): Codec<FetchResponse> => {
     if (_codec == null) {
-      _codec = message<FetchResponse>((obj, writer, opts = {}) => {
+      _codec = message<FetchResponse>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
-        if (obj.status != null) {
-          writer.uint32(8)
-          FetchResponse.StatusCode.codec().encode(obj.status, writer)
-        } else {
-          throw new Error('Protocol error: required field "status" was not found in object')
+        if (opts.writeDefaults === true || (obj.status != null && __StatusCodeValues[obj.status] !== 0)) {
+          w.uint32(8)
+          FetchResponse.StatusCode.codec().encode(obj.status, w)
         }
 
-        if (obj.data != null) {
-          writer.uint32(18)
-          writer.bytes(obj.data)
-        } else {
-          throw new Error('Protocol error: required field "data" was not found in object')
+        if (opts.writeDefaults === true || (obj.data != null && obj.data.byteLength > 0)) {
+          w.uint32(18)
+          w.bytes(obj.data)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
-        const obj: any = {}
+        const obj: any = {
+          status: StatusCode.OK,
+          data: new Uint8Array(0)
+        }
 
         const end = length == null ? reader.len : reader.pos + length
 
@@ -138,14 +135,6 @@ export namespace FetchResponse {
           }
         }
 
-        if (obj.status == null) {
-          throw new Error('Protocol error: value for required field "status" was not found in protobuf')
-        }
-
-        if (obj.data == null) {
-          throw new Error('Protocol error: value for required field "data" was not found in protobuf')
-        }
-
         return obj
       })
     }