libp2p 0.41.0-19e96cc → 0.41.0-3e53c19

package/src/address-manager/index.ts

@@ -7,6 +7,10 @@ import type { PeerId } from '@libp2p/interface-peer-id'
 import type { TransportManager } from '@libp2p/interface-transport'
 
 export interface AddressManagerInit {
+  /**
+   * Pass an function in this field to override the list of addresses
+   * that are announced to the network
+   */
   announceFilter?: AddressFilter
 
   /**
@@ -30,6 +34,10 @@ export interface DefaultAddressManagerComponents {
   transportManager: TransportManager
 }
 
+/**
+ * A function that takes a list of multiaddrs and returns a list
+ * to announce
+ */
 export interface AddressFilter {
   (addrs: Multiaddr[]): Multiaddr[]
 }

package/src/circuit/index.ts

@@ -12,12 +12,24 @@ import {
 } from './constants.js'
 import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { RelayConfig } from '../index.js'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { TransportManager } from '@libp2p/interface-transport'
 import type { PeerId } from '@libp2p/interface-peer-id'
 
+export interface RelayConfig {
+  enabled: boolean
+  advertise: RelayAdvertiseConfig
+  hop: HopConfig
+  autoRelay: AutoRelayConfig
+}
+
+export interface HopConfig {
+  enabled?: boolean
+  active?: boolean
+  timeout: number
+}
+
 const log = logger('libp2p:relay')
 
 export interface RelayAdvertiseConfig {

package/src/circuit/transport.ts

@@ -17,7 +17,7 @@ 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 } from '@libp2p/interface-connection'
-import type { RelayConfig } from '../index.js'
+import type { RelayConfig } from './index.js'
 import { abortableDuplex } from 'abortable-iterator'
 import { TimeoutController } from 'timeout-abort-controller'
 import { setMaxListeners } from 'events'

package/src/config.ts

@@ -31,7 +31,15 @@ const DefaultConfig: Partial<Libp2pInit> = {
     resolvers: {
       dnsaddr: dnsaddrResolver
     },
-    addressSorter: publicAddressesFirst
+    addressSorter: publicAddressesFirst,
+    maxEventLoopDelay: Infinity,
+    pollInterval: Infinity,
+    maxAddrsToDial: Infinity,
+    startupReconnectTimeout: Infinity,
+    allow: [],
+    deny: [],
+    maxIncomingPendingConnections: Infinity,
+    inboundConnectionThreshold: Infinity
   },
   connectionGater: {},
   transportManager: {
@@ -42,7 +50,8 @@ const DefaultConfig: Partial<Libp2pInit> = {
       enabled: true,
       interval: 6e5,
       bootDelay: 10e3
-    }
+    },
+    routers: []
   },
   nat: {
     enabled: true,

package/src/connection-manager/index.ts

@@ -11,8 +11,8 @@ import { setMaxListeners } from 'events'
 import type { Connection, MultiaddrConnection } from '@libp2p/interface-connection'
 import type { ConnectionManager, ConnectionManagerEvents, Dialer } from '@libp2p/interface-connection-manager'
 import * as STATUS from '@libp2p/interface-connection/status'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import { isMultiaddr, multiaddr, Multiaddr } from '@multiformats/multiaddr'
+import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
+import { isMultiaddr, 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'
@@ -20,10 +20,109 @@ import { RateLimiterMemory } from 'rate-limiter-flexible'
 import type { Metrics } from '@libp2p/interface-metrics'
 import type { Upgrader } from '@libp2p/interface-transport'
 import { getPeer } from '../get-peer.js'
-import type { ConnectionManagerConfig } from '../index.js'
 
 const log = logger('libp2p:connection-manager')
 
+export interface ConnectionManagerConfig {
+  /**
+   * The maximum number of connections libp2p is willing to have before it starts disconnecting. Defaults to `Infinity`
+   */
+  maxConnections: number
+
+  /**
+   * The minimum number of connections below which libp2p not activate preemptive disconnections. Defaults to `0`.
+   */
+  minConnections: number
+
+  /**
+   * Sets the maximum event loop delay (measured in milliseconds) this node is willing to endure before it starts disconnecting peers. Defaults to `Infinity`.
+   */
+  maxEventLoopDelay?: number
+
+  /**
+   * Sets the poll interval (in milliseconds) for assessing the current state and determining if this peer needs to force a disconnect. Defaults to `2000` (2 seconds).
+   */
+  pollInterval?: number
+
+  /**
+   * If true, try to connect to all discovered peers up to the connection manager limit
+   */
+  autoDial?: boolean
+
+  /**
+   * How long to wait between attempting to keep our number of concurrent connections
+   * above minConnections
+   */
+  autoDialInterval: number
+
+  /**
+   * Sort the known addresses of a peer before trying to dial
+   */
+  addressSorter?: AddressSorter
+
+  /**
+   * Number of max concurrent dials
+   */
+  maxParallelDials?: number
+
+  /**
+   * Number of max addresses to dial for a given peer
+   */
+  maxAddrsToDial?: number
+
+  /**
+   * How long a dial attempt is allowed to take, including DNS resolution
+   * of the multiaddr, opening a socket and upgrading it to a Connection.
+   */
+  dialTimeout?: number
+
+  /**
+   * When a new inbound connection is opened, the upgrade process (e.g. protect,
+   * encrypt, multiplex etc) must complete within this number of ms.
+   */
+  inboundUpgradeTimeout: number
+
+  /**
+   * Number of max concurrent dials per peer
+   */
+  maxDialsPerPeer?: number
+
+  /**
+   * Multiaddr resolvers to use when dialing
+   */
+  resolvers?: Record<string, Resolver>
+
+  /**
+   * On startup we try to dial any peer that has previously been
+   * 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
+}
+
 const defaultOptions: Partial<ConnectionManagerConfig> = {
   maxConnections: Infinity,
   minConnections: 0,

package/src/index.ts

@@ -16,14 +16,13 @@
 
 import { createLibp2pNode } from './libp2p.js'
 import type { RecursivePartial } from '@libp2p/interfaces'
-import type { Multiaddr, Resolver } from '@multiformats/multiaddr'
-import type { FaultTolerance } from './transport-manager.js'
+import type { TransportManagerInit } from './transport-manager.js'
 import type { IdentifyServiceInit } from './identify/index.js'
 import type { DualDHT } from '@libp2p/interface-dht'
 import type { Datastore } from 'interface-datastore'
-import type { AddressSorter, PeerStoreInit } from '@libp2p/interface-peer-store'
+import type { PeerStoreInit } from '@libp2p/interface-peer-store'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { AutoRelayConfig, RelayAdvertiseConfig } from './circuit/index.js'
+import type { RelayConfig } from './circuit/index.js'
 import type { PeerDiscovery } from '@libp2p/interface-peer-discovery'
 import type { ConnectionGater, ConnectionProtector } from '@libp2p/interface-connection'
 import type { Transport } from '@libp2p/interface-transport'
@@ -38,175 +37,11 @@ import type { PingServiceInit } from './ping/index.js'
 import type { FetchServiceInit } from './fetch/index.js'
 import type { Components } from './components.js'
 import type { Libp2p } from '@libp2p/interface-libp2p'
-
-export interface PersistentPeerStoreOptions {
-  threshold?: number
-}
-
-export interface DEKConfig {
-  keyLength: number
-  iterationCount: number
-  salt: string
-  hash: string
-}
-
-export interface KeychainConfig {
-  pass?: string
-  dek?: DEKConfig
-}
-
-export interface MetricsConfig {
-  enabled?: boolean
-}
-
-export interface HopConfig {
-  enabled?: boolean
-  active?: boolean
-  timeout: number
-}
-
-export interface RelayConfig {
-  enabled: boolean
-  advertise: RelayAdvertiseConfig
-  hop: HopConfig
-  autoRelay: AutoRelayConfig
-}
-
-export interface NatManagerConfig {
-  enabled: boolean
-  externalAddress?: string
-  localAddress?: string
-  description?: string
-  ttl?: number
-  keepAlive: boolean
-  gateway?: string
-}
-
-export interface AddressesConfig {
-  listen: string[]
-  announce: string[]
-  noAnnounce: string[]
-  announceFilter: (multiaddrs: Multiaddr[]) => Multiaddr[]
-}
-
-export interface TransportManagerConfig {
-  faultTolerance?: FaultTolerance
-}
-
-export interface PeerStoreConfig {
-  persistence?: boolean
-  threshold?: number
-}
-
-export interface PeerRoutingConfig {
-  refreshManager: RefreshManagerConfig
-}
-
-export interface RefreshManagerConfig {
-  enabled?: boolean
-  interval: number
-  bootDelay: number
-}
-
-export interface ConnectionManagerConfig {
-  /**
-   * The maximum number of connections libp2p is willing to have before it starts disconnecting. Defaults to `Infinity`
-   */
-  maxConnections: number
-
-  /**
-   * The minimum number of connections below which libp2p not activate preemptive disconnections. Defaults to `0`.
-   */
-  minConnections: number
-
-  /**
-   * Sets the maximum event loop delay (measured in milliseconds) this node is willing to endure before it starts disconnecting peers. Defaults to `Infinity`.
-   */
-  maxEventLoopDelay?: number
-
-  /**
-   * Sets the poll interval (in milliseconds) for assessing the current state and determining if this peer needs to force a disconnect. Defaults to `2000` (2 seconds).
-   */
-  pollInterval?: number
-
-  /**
-   * If true, try to connect to all discovered peers up to the connection manager limit
-   */
-  autoDial?: boolean
-
-  /**
-   * How long to wait between attempting to keep our number of concurrent connections
-   * above minConnections
-   */
-  autoDialInterval: number
-
-  /**
-   * Sort the known addresses of a peer before trying to dial
-   */
-  addressSorter?: AddressSorter
-
-  /**
-   * Number of max concurrent dials
-   */
-  maxParallelDials?: number
-
-  /**
-   * Number of max addresses to dial for a given peer
-   */
-  maxAddrsToDial?: number
-
-  /**
-   * How long a dial attempt is allowed to take, including DNS resolution
-   * of the multiaddr, opening a socket and upgrading it to a Connection.
-   */
-  dialTimeout?: number
-
-  /**
-   * When a new inbound connection is opened, the upgrade process (e.g. protect,
-   * encrypt, multiplex etc) must complete within this number of ms.
-   */
-  inboundUpgradeTimeout: number
-
-  /**
-   * Number of max concurrent dials per peer
-   */
-  maxDialsPerPeer?: number
-
-  /**
-   * Multiaddr resolvers to use when dialing
-   */
-  resolvers?: Record<string, Resolver>
-
-  /**
-   * On startup we try to dial any peer that has previously been
-   * 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
-}
+import type { KeyChainInit } from './keychain/index.js'
+import type { NatManagerInit } from './nat-manager.js'
+import type { AddressManagerInit } from './address-manager/index.js'
+import type { PeerRoutingInit } from './peer-routing.js'
+import type { ConnectionManagerInit } from './connection-manager/index.js'
 
 /**
  * For Libp2p configurations and modules details read the [Configuration Document](./CONFIGURATION.md).
@@ -220,18 +55,22 @@ export interface Libp2pInit {
   /**
    * Addresses for transport listening and to advertise to the network
    */
-  addresses: AddressesConfig
+  addresses: AddressManagerInit
 
   /**
    * libp2p Connection Manager configuration
    */
-  connectionManager: ConnectionManagerConfig
+  connectionManager: ConnectionManagerInit
+
+  /**
+   * A connection gater can deny new connections based on user criteria
+   */
   connectionGater: Partial<ConnectionGater>
 
   /**
    * libp2p transport manager configuration
    */
-  transportManager: TransportManagerConfig
+  transportManager: TransportManagerInit
 
   /**
    * An optional datastore to persist peer information, DHT records, etc.
@@ -248,13 +87,22 @@ export interface Libp2pInit {
   /**
    * libp2p Peer routing service configuration
    */
-  peerRouting: PeerRoutingConfig
+  peerRouting: PeerRoutingInit
 
   /**
    * keychain configuration
    */
-  keychain: KeychainConfig
-  nat: NatManagerConfig
+  keychain: KeyChainInit
+
+  /**
+   * The NAT manager controls uPNP hole punching
+   */
+  nat: NatManagerInit
+
+  /**
+   * If configured as a relay this node will relay certain
+   * types of traffic for other peers
+   */
   relay: RelayConfig
 
   /**

package/src/keychain/index.ts

@@ -17,7 +17,7 @@ import type { Datastore } from 'interface-datastore'
 
 const log = logger('libp2p:keychain')
 
-export interface DekOptions {
+export interface DEKConfig {
   hash: string
   salt: string
   iterationCount: number
@@ -26,7 +26,7 @@ export interface DekOptions {
 
 export interface KeyChainInit {
   pass?: string
-  dek?: DekOptions
+  dek?: DEKConfig
 }
 
 /**

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.41.0-19e96cc'
+export const version = '0.41.0-3e53c19'
 export const name = 'libp2p'