libp2p 0.44.0 → 0.45.0-08d4c261

package/src/components.ts

@@ -1,22 +1,23 @@
 import { CodeError } from '@libp2p/interfaces/errors'
+import { isStartable, type Startable } from '@libp2p/interfaces/startable'
+import type { AddressManager } from '@libp2p/interface-address-manager'
 import type { ConnectionProtector } from '@libp2p/interface-connection'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import { isStartable, Startable } from '@libp2p/interfaces/startable'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 import type { Metrics } from '@libp2p/interface-metrics'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { PeerRouting } from '@libp2p/interface-peer-routing'
 import type { PeerStore } from '@libp2p/interface-peer-store'
 import type { Registrar } from '@libp2p/interface-registrar'
 import type { TransportManager, Upgrader } from '@libp2p/interface-transport'
+import type { EventEmitter } from '@libp2p/interfaces/events'
 import type { Datastore } from 'interface-datastore'
-import type { PubSub } from '@libp2p/interface-pubsub'
-import type { DualDHT } from '@libp2p/interface-dht'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
 
-export interface Components {
+export interface Components extends Record<string, any>, Startable {
   peerId: PeerId
+  events: EventEmitter<Libp2pEvents>
   addressManager: AddressManager
   peerStore: PeerStore
   upgrader: Upgrader
@@ -29,12 +30,11 @@ export interface Components {
   datastore: Datastore
   connectionProtector?: ConnectionProtector
   metrics?: Metrics
-  dht?: DualDHT
-  pubsub?: PubSub
 }
 
 export interface ComponentsInit {
   peerId?: PeerId
+  events?: EventEmitter<Libp2pEvents>
   addressManager?: AddressManager
   peerStore?: PeerStore
   upgrader?: Upgrader
@@ -47,271 +47,108 @@ export interface ComponentsInit {
   peerRouting?: PeerRouting
   datastore?: Datastore
   connectionProtector?: ConnectionProtector
-  dht?: DualDHT
-  pubsub?: PubSub
 }
 
-export class DefaultComponents implements Components, Startable {
-  private _peerId?: PeerId
-  private _addressManager?: AddressManager
-  private _peerStore?: PeerStore
-  private _upgrader?: Upgrader
-  private _metrics?: Metrics
-  private _registrar?: Registrar
-  private _connectionManager?: ConnectionManager
-  private _transportManager?: TransportManager
-  private _connectionGater?: ConnectionGater
-  private _contentRouting?: ContentRouting
-  private _peerRouting?: PeerRouting
-  private _datastore?: Datastore
-  private _connectionProtector?: ConnectionProtector
-  private _dht?: DualDHT
-  private _pubsub?: PubSub
+class DefaultComponents implements Startable {
+  public components: Record<string, any> = {}
   private _started = false
 
   constructor (init: ComponentsInit = {}) {
-    this._peerId = init.peerId
-    this._addressManager = init.addressManager
-    this._peerStore = init.peerStore
-    this._upgrader = init.upgrader
-    this._metrics = init.metrics
-    this._registrar = init.registrar
-    this._connectionManager = init.connectionManager
-    this._transportManager = init.transportManager
-    this._connectionGater = init.connectionGater
-    this._contentRouting = init.contentRouting
-    this._peerRouting = init.peerRouting
-    this._datastore = init.datastore
-    this._connectionProtector = init.connectionProtector
-    this._dht = init.dht
-    this._pubsub = init.pubsub
+    this.components = {}
+
+    for (const [key, value] of Object.entries(init)) {
+      this.components[key] = value
+    }
   }
 
   isStarted (): boolean {
     return this._started
   }
 
-  async beforeStart (): Promise<void> {
+  private async _invokeStartableMethod (methodName: 'beforeStart' | 'start' | 'afterStart' | 'beforeStop' | 'stop' | 'afterStop'): Promise<void> {
     await Promise.all(
-      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
-        if (startable.beforeStart != null) {
-          await startable.beforeStart()
-        }
-      })
+      Object.values(this.components)
+        .filter(obj => isStartable(obj))
+        .map(async (startable: Startable) => {
+          await startable[methodName]?.()
+        })
     )
   }
 
-  async start (): Promise<void> {
-    await Promise.all(
-      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
-        await startable.start()
-      })
-    )
+  async beforeStart (): Promise<void> {
+    await this._invokeStartableMethod('beforeStart')
+  }
 
+  async start (): Promise<void> {
+    await this._invokeStartableMethod('start')
     this._started = true
   }
 
   async afterStart (): Promise<void> {
-    await Promise.all(
-      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
-        if (startable.afterStart != null) {
-          await startable.afterStart()
-        }
-      })
-    )
+    await this._invokeStartableMethod('afterStart')
   }
 
   async beforeStop (): Promise<void> {
-    await Promise.all(
-      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
-        if (startable.beforeStop != null) {
-          await startable.beforeStop()
-        }
-      })
-    )
+    await this._invokeStartableMethod('beforeStop')
   }
 
   async stop (): Promise<void> {
-    await Promise.all(
-      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
-        await startable.stop()
-      })
-    )
-
+    await this._invokeStartableMethod('stop')
     this._started = false
   }
 
   async afterStop (): Promise<void> {
-    await Promise.all(
-      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
-        if (startable.afterStop != null) {
-          await startable.afterStop()
-        }
-      })
-    )
-  }
-
-  get peerId (): PeerId {
-    if (this._peerId == null) {
-      throw new CodeError('peerId not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._peerId
-  }
-
-  set peerId (peerId: PeerId) {
-    this._peerId = peerId
-  }
-
-  get addressManager (): AddressManager {
-    if (this._addressManager == null) {
-      throw new CodeError('addressManager not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._addressManager
-  }
-
-  set addressManager (addressManager: AddressManager) {
-    this._addressManager = addressManager
-  }
-
-  get peerStore (): PeerStore {
-    if (this._peerStore == null) {
-      throw new CodeError('peerStore not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._peerStore
-  }
-
-  set peerStore (peerStore: PeerStore) {
-    this._peerStore = peerStore
-  }
-
-  get upgrader (): Upgrader {
-    if (this._upgrader == null) {
-      throw new CodeError('upgrader not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._upgrader
-  }
-
-  set upgrader (upgrader: Upgrader) {
-    this._upgrader = upgrader
-  }
-
-  get registrar (): Registrar {
-    if (this._registrar == null) {
-      throw new CodeError('registrar not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._registrar
-  }
-
-  set registrar (registrar: Registrar) {
-    this._registrar = registrar
-  }
-
-  get connectionManager (): ConnectionManager {
-    if (this._connectionManager == null) {
-      throw new CodeError('connectionManager not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._connectionManager
-  }
-
-  set connectionManager (connectionManager: ConnectionManager) {
-    this._connectionManager = connectionManager
-  }
-
-  get transportManager (): TransportManager {
-    if (this._transportManager == null) {
-      throw new CodeError('transportManager not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._transportManager
-  }
-
-  set transportManager (transportManager: TransportManager) {
-    this._transportManager = transportManager
-  }
-
-  get connectionGater (): ConnectionGater {
-    if (this._connectionGater == null) {
-      throw new CodeError('connectionGater not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._connectionGater
-  }
-
-  set connectionGater (connectionGater: ConnectionGater) {
-    this._connectionGater = connectionGater
-  }
-
-  get contentRouting (): ContentRouting {
-    if (this._contentRouting == null) {
-      throw new CodeError('contentRouting not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._contentRouting
+    await this._invokeStartableMethod('afterStop')
   }
+}
 
-  set contentRouting (contentRouting: ContentRouting) {
-    this._contentRouting = contentRouting
-  }
+const OPTIONAL_SERVICES = [
+  'metrics',
+  'connectionProtector'
+]
+
+const NON_SERVICE_PROPERTIES = [
+  'components',
+  'isStarted',
+  'beforeStart',
+  'start',
+  'afterStart',
+  'beforeStop',
+  'stop',
+  'afterStop',
+  'then',
+  '_invokeStartableMethod'
+]
+
+export function defaultComponents (init: ComponentsInit = {}): Components {
+  const components = new DefaultComponents(init)
+
+  const proxy = new Proxy(components, {
+    get (target, prop, receiver) {
+      if (typeof prop === 'string' && !NON_SERVICE_PROPERTIES.includes(prop)) {
+        const service = components.components[prop]
+
+        if (service == null && !OPTIONAL_SERVICES.includes(prop)) {
+          throw new CodeError(`${prop} not set`, 'ERR_SERVICE_MISSING')
+        }
 
-  get peerRouting (): PeerRouting {
-    if (this._peerRouting == null) {
-      throw new CodeError('peerRouting not set', 'ERR_SERVICE_MISSING')
-    }
+        return service
+      }
 
-    return this._peerRouting
-  }
+      return Reflect.get(target, prop, receiver)
+    },
 
-  set peerRouting (peerRouting: PeerRouting) {
-    this._peerRouting = peerRouting
-  }
+    set (target, prop, value) {
+      if (typeof prop === 'string') {
+        components.components[prop] = value
+      } else {
+        Reflect.set(target, prop, value)
+      }
 
-  get datastore (): Datastore {
-    if (this._datastore == null) {
-      throw new CodeError('datastore not set', 'ERR_SERVICE_MISSING')
+      return true
     }
+  })
 
-    return this._datastore
-  }
-
-  set datastore (datastore: Datastore) {
-    this._datastore = datastore
-  }
-
-  get connectionProtector (): ConnectionProtector | undefined {
-    return this._connectionProtector
-  }
-
-  set connectionProtector (connectionProtector: ConnectionProtector | undefined) {
-    this._connectionProtector = connectionProtector
-  }
-
-  get metrics (): Metrics | undefined {
-    return this._metrics
-  }
-
-  set metrics (metrics: Metrics | undefined) {
-    this._metrics = metrics
-  }
-
-  get dht (): DualDHT | undefined {
-    return this._dht
-  }
-
-  set dht (dht: DualDHT | undefined) {
-    this._dht = dht
-  }
-
-  get pubsub (): PubSub | undefined {
-    return this._pubsub
-  }
-
-  set pubsub (pubsub: PubSub | undefined) {
-    this._pubsub = pubsub
-  }
+  // @ts-expect-error component keys are proxied
+  return proxy
 }

package/src/config/connection-gater.browser.ts

@@ -0,0 +1,31 @@
+import isPrivate from 'private-ip'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+/**
+ * Returns a connection gater that disallows dialling private addresses by
+ * default. Browsers are severely limited in their resource usage so don't
+ * waste time trying to dial undiallable addresses.
+ */
+export function connectionGater (gater: ConnectionGater = {}): ConnectionGater {
+  return {
+    denyDialPeer: async () => false,
+    denyDialMultiaddr: async (multiaddr: Multiaddr) => {
+      const tuples = multiaddr.stringTuples()
+
+      if (tuples[0][0] === 4 || tuples[0][0] === 41) {
+        return Boolean(isPrivate(`${tuples[0][1]}`))
+      }
+
+      return false
+    },
+    denyInboundConnection: async () => false,
+    denyOutboundConnection: async () => false,
+    denyInboundEncryptedConnection: async () => false,
+    denyOutboundEncryptedConnection: async () => false,
+    denyInboundUpgradedConnection: async () => false,
+    denyOutboundUpgradedConnection: async () => false,
+    filterMultiaddrForPeer: async () => true,
+    ...gater
+  }
+}

package/src/config/connection-gater.ts

@@ -0,0 +1,19 @@
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+
+/**
+ * Returns a default connection gater implementation that allows everything
+ */
+export function connectionGater (gater: ConnectionGater = {}): ConnectionGater {
+  return {
+    denyDialPeer: async () => false,
+    denyDialMultiaddr: async () => false,
+    denyInboundConnection: async () => false,
+    denyOutboundConnection: async () => false,
+    denyInboundEncryptedConnection: async () => false,
+    denyOutboundEncryptedConnection: async () => false,
+    denyInboundUpgradedConnection: async () => false,
+    denyOutboundUpgradedConnection: async () => false,
+    filterMultiaddrForPeer: async () => true,
+    ...gater
+  }
+}

package/src/config.ts

@@ -1,14 +1,13 @@
-import mergeOptions from 'merge-options'
-import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
-import { AGENT_VERSION } from './identify/consts.js'
-import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { FaultTolerance } from '@libp2p/interface-transport'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { Libp2pInit } from './index.js'
-import { codes, messages } from './errors.js'
 import { CodeError } from '@libp2p/interfaces/errors'
+import { publicAddressesFirst } from '@libp2p/utils/address-sort'
+import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
+import mergeOptions from 'merge-options'
+import { codes, messages } from './errors.js'
+import type { Libp2pInit } from './index.js'
+import type { ServiceMap } from '@libp2p/interface-libp2p'
 import type { RecursivePartial } from '@libp2p/interfaces'
-import { isNode, isBrowser, isWebWorker, isElectronMain, isElectronRenderer, isReactNative } from 'wherearewe'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 const DefaultConfig: Partial<Libp2pInit> = {
   addresses: {
@@ -25,62 +24,11 @@ const DefaultConfig: Partial<Libp2pInit> = {
   },
   transportManager: {
     faultTolerance: FaultTolerance.FATAL_ALL
-  },
-  peerRouting: {
-    refreshManager: {
-      enabled: true,
-      interval: 6e5,
-      bootDelay: 10e3
-    }
-  },
-  nat: {
-    enabled: true,
-    ttl: 7200,
-    keepAlive: true
-  },
-  identify: {
-    protocolPrefix: 'ipfs',
-    host: {
-      agentVersion: AGENT_VERSION
-    },
-    // https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/identify/id.go#L48
-    timeout: 60000,
-    maxInboundStreams: 1,
-    maxOutboundStreams: 1,
-    maxPushIncomingStreams: 1,
-    maxPushOutgoingStreams: 1,
-    maxObservedAddresses: 10
-  },
-  ping: {
-    protocolPrefix: 'ipfs',
-    // See https://github.com/libp2p/specs/blob/d4b5fb0152a6bb86cfd9ea/ping/ping.md?plain=1#L38-L43
-    // The dialing peer MUST NOT keep more than one outbound stream for the ping protocol per peer.
-    // The listening peer SHOULD accept at most two streams per peer since cross-stream behavior is
-    // non-linear and stream writes occur asynchronously. The listening peer may perceive the
-    // dialing peer closing and opening the wrong streams (for instance, closing stream B and
-    // opening stream A even though the dialing peer is opening stream B and closing stream A).
-    maxInboundStreams: 2,
-    maxOutboundStreams: 1,
-    timeout: 10000
-  },
-  fetch: {
-    protocolPrefix: 'libp2p',
-    maxInboundStreams: 1,
-    maxOutboundStreams: 1,
-    timeout: 10000
-  },
-  autonat: {
-    protocolPrefix: 'libp2p',
-    maxInboundStreams: 1,
-    maxOutboundStreams: 1,
-    timeout: 30000,
-    startupDelay: 5000,
-    refreshInterval: 60000
   }
 }
 
-export function validateConfig (opts: RecursivePartial<Libp2pInit>): Libp2pInit {
-  const resultingOptions: Libp2pInit = mergeOptions(DefaultConfig, opts)
+export function validateConfig <T extends ServiceMap = Record<string, unknown>> (opts: RecursivePartial<Libp2pInit<T>>): Libp2pInit<T> {
+  const resultingOptions: Libp2pInit<T> = mergeOptions(DefaultConfig, opts)
 
   if (resultingOptions.transports == null || resultingOptions.transports.length < 1) {
     throw new CodeError(messages.ERR_TRANSPORTS_REQUIRED, codes.ERR_TRANSPORTS_REQUIRED)
@@ -94,14 +42,5 @@ export function validateConfig (opts: RecursivePartial<Libp2pInit>): Libp2pInit
     throw new CodeError(messages.ERR_PROTECTOR_REQUIRED, codes.ERR_PROTECTOR_REQUIRED)
   }
 
-  // Append user agent version to default AGENT_VERSION depending on the environment
-  if (resultingOptions.identify.host.agentVersion === AGENT_VERSION) {
-    if (isNode || isElectronMain) {
-      resultingOptions.identify.host.agentVersion += ` UserAgent=${globalThis.process.version}`
-    } else if (isBrowser || isWebWorker || isElectronRenderer || isReactNative) {
-      resultingOptions.identify.host.agentVersion += ` UserAgent=${globalThis.navigator.userAgent}`
-    }
-  }
-
   return resultingOptions
 }

package/src/connection/index.ts

@@ -1,11 +1,11 @@
-import type { Multiaddr } from '@multiformats/multiaddr'
-import { CodeError } from '@libp2p/interfaces/errors'
-import { OPEN, CLOSING, CLOSED } from '@libp2p/interface-connection/status'
 import { symbol } from '@libp2p/interface-connection'
+import { OPEN, CLOSING, CLOSED } from '@libp2p/interface-connection/status'
+import { CodeError } from '@libp2p/interfaces/errors'
+import { logger } from '@libp2p/logger'
 import type { Connection, ConnectionStat, Stream } from '@libp2p/interface-connection'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import { logger } from '@libp2p/logger'
 import type { AbortOptions } from '@libp2p/interfaces'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:connection')
 
@@ -87,13 +87,9 @@ export class ConnectionImpl implements Connection {
     this._closing = false
   }
 
-  get [Symbol.toStringTag] (): 'Connection' {
-    return 'Connection'
-  }
+  readonly [Symbol.toStringTag] = 'Connection'
 
-  get [symbol] (): true {
-    return true
-  }
+  readonly [symbol] = true
 
   /**
    * Get all the streams of the muxer