libp2p 0.44.0 → 0.45.0-752db6d6

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) {

package/src/connection-manager/connection-pruner.ts

@@ -4,7 +4,8 @@ import type { PeerStore } from '@libp2p/interface-peer-store'
 import { PeerMap } from '@libp2p/peer-collections'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import { MAX_CONNECTIONS } from './constants.js'
-import { CustomEvent } from '@libp2p/interfaces/events'
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:connection-manager:connection-pruner')
 
@@ -16,6 +17,7 @@ interface ConnectionPrunerInit {
 interface ConnectionPrunerComponents {
   connectionManager: ConnectionManager
   peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 const defaultOptions = {
@@ -31,12 +33,22 @@ export class ConnectionPruner {
   private readonly connectionManager: ConnectionManager
   private readonly peerStore: PeerStore
   private readonly allow: Multiaddr[]
+  private readonly events: EventEmitter<Libp2pEvents>
 
   constructor (components: ConnectionPrunerComponents, init: ConnectionPrunerInit = {}) {
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
     this.allow = init.allow ?? defaultOptions.allow
     this.connectionManager = components.connectionManager
     this.peerStore = components.peerStore
+    this.events = components.events
+
+    // check the max connection limit whenever a peer connects
+    components.events.addEventListener('connection:open', () => {
+      this.maybePruneConnections()
+        .catch(err => {
+          log.error(err)
+        })
+    })
   }
 
   /**
@@ -48,7 +60,7 @@ export class ConnectionPruner {
     const numConnections = connections.length
     const toPrune = Math.max(numConnections - this.maxConnections, 0)
 
-    log.trace('checking max connections limit %d/%d', numConnections, this.maxConnections)
+    log('checking max connections limit %d/%d', numConnections, this.maxConnections)
     if (numConnections <= this.maxConnections) {
       return
     }
@@ -64,12 +76,20 @@ export class ConnectionPruner {
         continue
       }
 
-      const tags = await this.peerStore.getTags(remotePeer)
+      peerValues.set(remotePeer, 0)
 
-      // sum all tag values
-      peerValues.set(remotePeer, tags.reduce((acc, curr) => {
-        return acc + curr.value
-      }, 0))
+      try {
+        const peer = await this.peerStore.get(remotePeer)
+
+        // sum all tag values
+        peerValues.set(remotePeer, [...peer.tags.values()].reduce((acc, curr) => {
+          return acc + curr.value
+        }, 0))
+      } catch (err: any) {
+        if (err.code !== 'ERR_NOT_FOUND') {
+          log.error('error loading peer tags', err)
+        }
+      }
     }
 
     // sort by value, lowest to highest
@@ -132,6 +152,6 @@ export class ConnectionPruner {
     )
 
     // despatch prune event
-    this.connectionManager.dispatchEvent(new CustomEvent('peer:prune', { detail: toClose.map(conn => conn.remotePeer) }))
+    this.events.safeDispatchEvent('connection:prune', { detail: toClose })
   }
 }

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

@@ -1,7 +1,6 @@
 import { logger } from '@libp2p/logger'
 import { AbortError, CodeError } from '@libp2p/interfaces/errors'
 import { Multiaddr, Resolver, resolvers } from '@multiformats/multiaddr'
-import { TimeoutController } from 'timeout-abort-controller'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { codes } from '../errors.js'
 import {
@@ -14,7 +13,7 @@ import type { Connection } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import { getPeerAddress } from '../get-peer.js'
-import type { Address, AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
+import type { Address, PeerStore } from '@libp2p/interface-peer-store'
 import type { Metric, Metrics } from '@libp2p/interface-metrics'
 import type { TransportManager } from '@libp2p/interface-transport'
 import type { ConnectionGater } from '@libp2p/interface-connection-gater'
@@ -22,7 +21,9 @@ import PQueue from 'p-queue'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import { combineSignals, resolveMultiaddrs } from './utils.js'
 import pDefer from 'p-defer'
-import type { ClearableSignal } from 'any-signal'
+import { ClearableSignal, anySignal } from 'any-signal'
+import type { AddressSorter } from '@libp2p/interface-libp2p'
+import { setMaxListeners } from 'events'
 
 const log = logger('libp2p:connection-manager:dial-queue')
 
@@ -100,6 +101,11 @@ export class DialQueue {
     this.transportManager = components.transportManager
     this.shutDownController = new AbortController()
 
+    try {
+      // This emitter gets listened to a lot
+      setMaxListeners?.(Infinity, this.shutDownController.signal)
+    } catch {}
+
     this.pendingDialCount = components.metrics?.registerMetric('libp2p_dialler_pending_dials')
     this.inProgressDialCount = components.metrics?.registerMetric('libp2p_dialler_in_progress_dials')
     this.pendingDials = []
@@ -175,7 +181,7 @@ export class DialQueue {
 
     // create abort conditions - need to do this before `calculateMultiaddrs` as we may be about to
     // resolve a dns addr which can time out
-    const { timeoutController, signal } = this.createDialAbortControllers(options.signal)
+    const signal = this.createDialAbortControllers(options.signal)
     let addrsToDial: Address[]
 
     try {
@@ -186,7 +192,6 @@ export class DialQueue {
       })
     } catch (err) {
       signal.clear()
-      timeoutController.clear()
       throw err
     }
 
@@ -209,7 +214,6 @@ export class DialQueue {
     if (existingDial != null) {
       log('joining existing dial target for %p', peerId)
       signal.clear()
-      timeoutController.clear()
       return await existingDial.promise
     }
 
@@ -232,13 +236,12 @@ export class DialQueue {
 
         // clean up abort signals/controllers
         signal.clear()
-        timeoutController.clear()
       })
       .catch(err => {
-        log.error('dial failed to %s', addrsToDial.map(({ multiaddr }) => multiaddr.toString()).join(', '), err)
+        log.error('dial failed to %s', pendingDial.multiaddrs.map(ma => ma.toString()).join(', '), err)
 
         // Error is a timeout
-        if (timeoutController.signal.aborted) {
+        if (signal.aborted) {
           const error = new CodeError(err.message, codes.ERR_TIMEOUT)
           throw error
         }
@@ -252,18 +255,21 @@ export class DialQueue {
     return await pendingDial.promise
   }
 
-  private createDialAbortControllers (userSignal?: AbortSignal): { timeoutController: TimeoutController, signal: ClearableSignal } {
-    // ensure we throw if the dial takes longer than the dial timeout
-    const timeoutController = new TimeoutController(this.dialTimeout)
-
+  private createDialAbortControllers (userSignal?: AbortSignal): ClearableSignal {
     // let any signal abort the dial
-    const signal = combineSignals(
-      timeoutController.signal,
-      this.shutDownController.signal,
-      userSignal
+    const signal = anySignal(
+      [AbortSignal.timeout(this.dialTimeout),
+        this.shutDownController.signal,
+        userSignal
+      ]
     )
 
-    return { timeoutController, signal }
+    try {
+      // This emitter gets listened to a lot
+      setMaxListeners?.(Infinity, signal)
+    } catch {}
+
+    return signal
   }
 
   private async calculateMultiaddrs (peerId?: PeerId, addrs: Address[] = [], options: DialOptions = {}): Promise<Address[]> {
@@ -280,8 +286,15 @@ export class DialQueue {
       // if just a peer id was passed, load available multiaddrs for this peer from the address book
       if (addrs.length === 0) {
         log('loading multiaddrs for %p', peerId)
-        addrs.push(...(await this.peerStore.addressBook.get(peerId)))
-        log('loaded multiaddrs for %p', peerId, addrs.map(({ multiaddr }) => multiaddr.toString()))
+        try {
+          const peer = await this.peerStore.get(peerId)
+          addrs.push(...peer.addresses)
+          log('loaded multiaddrs for %p', peerId, addrs.map(({ multiaddr }) => multiaddr.toString()))
+        } catch (err: any) {
+          if (err.code !== codes.ERR_NOT_FOUND) {
+            throw err
+          }
+        }
       }
     }
 
@@ -371,7 +384,14 @@ export class DialQueue {
       gatedAdrs.push(addr)
     }
 
-    return gatedAdrs.sort(this.addressSorter)
+    const sortedGatedAddrs = gatedAdrs.sort(this.addressSorter)
+
+    // make sure we actually have some addresses to dial
+    if (sortedGatedAddrs.length === 0) {
+      throw new CodeError('The connection gater denied all addresses in the dial request', codes.ERR_NO_VALID_ADDRESSES)
+    }
+
+    return sortedGatedAddrs
   }
 
   private async performDial (pendingDial: PendingDial, options: DialOptions = {}): Promise<Connection> {