libp2p 0.44.0 → 0.45.0

package/src/components.ts

@@ -10,13 +10,14 @@ 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 { 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'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
+import type { EventEmitter } from '@libp2p/interfaces/events'
 
-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 type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import isPrivate from 'private-ip'
+
+/**
+ * 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,6 +1,5 @@
 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'
@@ -8,7 +7,7 @@ import type { Libp2pInit } from './index.js'
 import { codes, messages } from './errors.js'
 import { CodeError } from '@libp2p/interfaces/errors'
 import type { RecursivePartial } from '@libp2p/interfaces'
-import { isNode, isBrowser, isWebWorker, isElectronMain, isElectronRenderer, isReactNative } from 'wherearewe'
+import type { ServiceMap } from '@libp2p/interface-libp2p'
 
 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 = {}> (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-manager/auto-dial.ts

@@ -1,10 +1,12 @@
 import { logger } from '@libp2p/logger'
 import type { PeerStore } from '@libp2p/interface-peer-store'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import { PeerMap } from '@libp2p/peer-collections'
+import { PeerMap, PeerSet } from '@libp2p/peer-collections'
 import PQueue from 'p-queue'
 import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_INTERVAL, AUTO_DIAL_PRIORITY, MIN_CONNECTIONS } from './constants.js'
 import type { Startable } from '@libp2p/interfaces/startable'
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:connection-manager:auto-dial')
 
@@ -18,6 +20,7 @@ interface AutoDialInit {
 interface AutoDialComponents {
   connectionManager: ConnectionManager
   peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 const defaultOptions = {
@@ -55,6 +58,14 @@ export class AutoDial implements Startable {
     this.queue.addListener('error', (err) => {
       log.error('error during auto-dial', err)
     })
+
+    // check the min connection limit whenever a peer disconnects
+    components.events.addEventListener('connection:close', () => {
+      this.autoDial()
+        .catch(err => {
+          log.error(err)
+        })
+    })
   }
 
   isStarted (): boolean {
@@ -86,7 +97,18 @@ export class AutoDial implements Startable {
   }
 
   async autoDial (): Promise<void> {
-    const numConnections = this.connectionManager.getConnections().length
+    if (!this.started) {
+      return
+    }
+
+    const connections = this.connectionManager.getConnectionsMap()
+    const numConnections = connections.size
+    const dialQueue = new PeerSet(
+      // @ts-expect-error boolean filter removes falsy peer IDs
+      this.connectionManager.getDialQueue()
+        .map(queue => queue.peerId)
+        .filter(Boolean)
+    )
 
     // Already has enough connections
     if (numConnections >= this.minConnections) {
@@ -97,40 +119,47 @@ export class AutoDial implements Startable {
     log('not enough connections %d/%d - will dial peers to increase the number of connections', numConnections, this.minConnections)
 
     // Sort peers on whether we know protocols or public keys for them
-    let peers = await this.peerStore.all()
-
-    log('loaded %d peers from the peer store', peers.length)
+    const peers = await this.peerStore.all()
 
     // Remove some peers
-    peers = peers.filter((peer) => {
+    const filteredPeers = peers.filter((peer) => {
       // Remove peers without addresses
       if (peer.addresses.length === 0) {
         return false
       }
 
+      // remove peers we are already connected to
+      if (connections.has(peer.id)) {
+        return false
+      }
+
+      // remove peers we are already dialling
+      if (dialQueue.has(peer.id)) {
+        return false
+      }
+
       return true
     })
 
-    // shuffle the peers
-    peers = peers.sort(() => Math.random() > 0.5 ? 1 : -1)
+    // shuffle the peers - this is so peers with the same tag values will be
+    // dialled in a different order each time
+    const shuffledPeers = filteredPeers.sort(() => Math.random() > 0.5 ? 1 : -1)
 
     // Sort shuffled peers by tag value
     const peerValues = new PeerMap<number>()
-    for (const peer of peers) {
+    for (const peer of shuffledPeers) {
       if (peerValues.has(peer.id)) {
         continue
       }
 
-      const tags = await this.peerStore.getTags(peer.id)
-
       // sum all tag values
-      peerValues.set(peer.id, (tags ?? []).reduce((acc, curr) => {
+      peerValues.set(peer.id, [...peer.tags.values()].reduce((acc, curr) => {
         return acc + curr.value
       }, 0))
     }
 
     // sort by value, highest to lowest
-    const sortedPeers = peers.sort((a, b) => {
+    const sortedPeers = shuffledPeers.sort((a, b) => {
       const peerAValue = peerValues.get(a.id) ?? 0
       const peerBValue = peerValues.get(b.id) ?? 0
 
@@ -145,11 +174,11 @@ export class AutoDial implements Startable {
       return 0
     })
 
-    log('selected %d peers to dial', sortedPeers.length)
+    log('selected %d/%d peers to dial', sortedPeers.length, peers.length)
 
     for (const peer of sortedPeers) {
       this.queue.add(async () => {
-        const numConnections = this.connectionManager.getConnections().length
+        const numConnections = this.connectionManager.getConnectionsMap().size
 
         // Check to see if we still need to auto dial
         if (numConnections >= this.minConnections) {