libp2p 0.46.16-d5ef1c91 → 0.46.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "0.46.16-d5ef1c91",
+  "version": "0.46.17",
   "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/master/packages/libp2p#readme",
@@ -100,7 +100,7 @@
   "scripts": {
     "clean": "aegir clean",
     "lint": "aegir lint",
-    "dep-check": "aegir dep-check -i events",
+    "dep-check": "aegir dep-check",
     "prepublishOnly": "node scripts/update-version.js && npm run build",
     "build": "aegir build",
     "generate": "run-s generate:proto:*",
@@ -121,25 +121,24 @@
   },
   "dependencies": {
     "@achingbrain/nat-port-mapper": "^1.0.9",
-    "@libp2p/crypto": "2.0.6-d5ef1c91",
-    "@libp2p/interface": "0.1.4-d5ef1c91",
-    "@libp2p/interface-internal": "0.1.7-d5ef1c91",
-    "@libp2p/keychain": "3.0.6-d5ef1c91",
-    "@libp2p/logger": "3.0.4-d5ef1c91",
-    "@libp2p/multistream-select": "4.0.4-d5ef1c91",
-    "@libp2p/peer-collections": "4.0.6-d5ef1c91",
-    "@libp2p/peer-id": "3.0.4-d5ef1c91",
-    "@libp2p/peer-id-factory": "3.0.6-d5ef1c91",
-    "@libp2p/peer-record": "6.0.7-d5ef1c91",
-    "@libp2p/peer-store": "9.0.7-d5ef1c91",
-    "@libp2p/utils": "4.0.5-d5ef1c91",
+    "@libp2p/crypto": "^2.0.7",
+    "@libp2p/interface": "^0.1.5",
+    "@libp2p/interface-internal": "^0.1.8",
+    "@libp2p/keychain": "^3.0.7",
+    "@libp2p/logger": "^3.0.5",
+    "@libp2p/multistream-select": "^4.0.5",
+    "@libp2p/peer-collections": "^4.0.7",
+    "@libp2p/peer-id": "^3.0.5",
+    "@libp2p/peer-id-factory": "^3.0.7",
+    "@libp2p/peer-record": "^6.0.8",
+    "@libp2p/peer-store": "^9.0.8",
+    "@libp2p/utils": "^4.0.6",
     "@multiformats/mafmt": "^12.1.2",
     "@multiformats/multiaddr": "^12.1.5",
     "@multiformats/multiaddr-matcher": "^1.0.0",
     "any-signal": "^4.1.1",
     "datastore-core": "^9.0.1",
     "delay": "^6.0.0",
-    "events": "^3.3.0",
     "interface-datastore": "^8.2.0",
     "it-all": "^3.0.2",
     "it-drain": "^3.0.2",
@@ -171,17 +170,17 @@
     "@chainsafe/libp2p-gossipsub": "^10.0.0",
     "@chainsafe/libp2p-noise": "^13.0.0",
     "@chainsafe/libp2p-yamux": "^5.0.0",
-    "@libp2p/bootstrap": "9.0.9-d5ef1c91",
+    "@libp2p/bootstrap": "^9.0.10",
     "@libp2p/daemon-client": "^7.0.0",
     "@libp2p/daemon-server": "^6.0.0",
-    "@libp2p/floodsub": "8.0.10-d5ef1c91",
-    "@libp2p/interface-compliance-tests": "4.1.2-d5ef1c91",
+    "@libp2p/floodsub": "^8.0.11",
+    "@libp2p/interface-compliance-tests": "^4.1.3",
     "@libp2p/interop": "^9.0.0",
-    "@libp2p/kad-dht": "10.0.11-d5ef1c91",
-    "@libp2p/mdns": "9.0.11-d5ef1c91",
-    "@libp2p/mplex": "9.0.9-d5ef1c91",
-    "@libp2p/tcp": "8.0.10-d5ef1c91",
-    "@libp2p/websockets": "7.0.10-d5ef1c91",
+    "@libp2p/kad-dht": "^10.0.12",
+    "@libp2p/mdns": "^9.0.12",
+    "@libp2p/mplex": "^9.0.10",
+    "@libp2p/tcp": "^8.0.11",
+    "@libp2p/websockets": "^7.0.11",
     "@types/xsalsa20": "^1.1.0",
     "aegir": "^41.0.2",
     "execa": "^8.0.1",
@@ -194,7 +193,7 @@
     "p-wait-for": "^5.0.2",
     "protons": "^7.0.2",
     "sinon": "^17.0.0",
-    "sinon-ts": "^1.0.0"
+    "sinon-ts": "^2.0.0"
   },
   "browser": {
     "./dist/src/connection-manager/constants.js": "./dist/src/connection-manager/constants.browser.js",

package/src/autonat/index.ts

@@ -19,8 +19,8 @@
  * ```
  */
 
-import { setMaxListeners } from 'events'
 import { CodeError } from '@libp2p/interface/errors'
+import { setMaxListeners } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { peerIdFromBytes } from '@libp2p/peer-id'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
@@ -164,10 +164,7 @@ class DefaultAutoNATService implements Startable {
 
     // this controller may be used while dialing lots of peers so prevent MaxListenersExceededWarning
     // appearing in the console
-    try {
-      // fails on node < 15.4
-      setMaxListeners?.(Infinity, signal)
-    } catch {}
+    setMaxListeners(Infinity, signal)
 
     const ourHosts = this.components.addressManager.getAddresses()
       .map(ma => ma.toOptions().host)
@@ -432,10 +429,7 @@ class DefaultAutoNATService implements Startable {
 
     // this controller may be used while dialing lots of peers so prevent MaxListenersExceededWarning
     // appearing in the console
-    try {
-      // fails on node < 15.4
-      setMaxListeners?.(Infinity, signal)
-    } catch {}
+    setMaxListeners(Infinity, signal)
 
     const self = this
 

package/src/circuit-relay/server/index.ts

@@ -1,5 +1,4 @@
-import { setMaxListeners } from 'events'
-import { TypedEventEmitter } from '@libp2p/interface/events'
+import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { peerIdFromBytes } from '@libp2p/peer-id'
 import { RecordEnvelope } from '@libp2p/peer-record'
@@ -134,10 +133,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
     this.maxOutboundHopStreams = init.maxOutboundHopStreams
     this.maxOutboundStopStreams = init.maxOutboundStopStreams ?? defaults.maxOutboundStopStreams
 
-    try {
-      // fails on node < 15.4
-      setMaxListeners?.(Infinity, this.shutdownController.signal)
-    } catch { }
+    setMaxListeners(Infinity, this.shutdownController.signal)
 
     if (init.advertise != null && init.advertise !== false) {
       this.advertService = new AdvertService(components, init.advertise === true ? undefined : init.advertise)

package/src/circuit-relay/transport/discovery.ts

@@ -57,6 +57,7 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
     // register a topology listener for when new peers are encountered
     // that support the hop protocol
     this.topologyId = await this.registrar.register(RELAY_V2_HOP_CODEC, {
+      notifyOnTransient: true,
       onConnect: (peerId) => {
         this.safeDispatchEvent('relay:discover', { detail: peerId })
       }

package/src/circuit-relay/transport/listener.ts

@@ -2,10 +2,8 @@ import { CodeError } from '@libp2p/interface/errors'
 import { TypedEventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { PeerMap } from '@libp2p/peer-collections'
-import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
 import type { ReservationStore } from './reservation-store.js'
-import type { Connection } from '@libp2p/interface/connection'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Listener, ListenerEvents } from '@libp2p/interface/transport'
 import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
@@ -41,25 +39,9 @@ class CircuitRelayTransportListener extends TypedEventEmitter<ListenerEvents> im
   async listen (addr: Multiaddr): Promise<void> {
     log('listen on %a', addr)
 
-    const relayPeerStr = addr.getPeerId()
-    let relayConn: Connection | undefined
-
-    // check if we already have a connection to the relay
-    if (relayPeerStr != null) {
-      const relayPeer = peerIdFromString(relayPeerStr)
-      const connections = this.connectionManager.getConnectionsMap().get(relayPeer) ?? []
-
-      if (connections.length > 0) {
-        relayConn = connections[0]
-      }
-    }
-
-    // open a new connection as we don't already have one
-    if (relayConn == null) {
-      const addrString = addr.toString().split('/p2p-circuit').find(a => a !== '')
-      const ma = multiaddr(addrString)
-      relayConn = await this.connectionManager.openConnection(ma)
-    }
+    // remove the circuit part to get the peer id of the relay
+    const relayAddr = addr.decapsulate('/p2p-circuit')
+    const relayConn = await this.connectionManager.openConnection(relayAddr)
 
     if (!this.relayStore.hasReservation(relayConn.remotePeer)) {
       // addRelay calls transportManager.listen which calls this listen method

package/src/connection/index.ts

@@ -1,6 +1,6 @@
-import { setMaxListeners } from 'events'
 import { symbol } from '@libp2p/interface/connection'
 import { CodeError } from '@libp2p/interface/errors'
+import { setMaxListeners } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import type { AbortOptions } from '@libp2p/interface'
 import type { Direction, Connection, Stream, ConnectionTimeline, ConnectionStatus, NewStreamOptions } from '@libp2p/interface/connection'
@@ -93,6 +93,10 @@ export class ConnectionImpl implements Connection {
     this.encryption = init.encryption
     this.transient = init.transient ?? false
 
+    if (this.remoteAddr.getPeerId() == null) {
+      this.remoteAddr = this.remoteAddr.encapsulate(`/p2p/${this.remotePeer}`)
+    }
+
     this._newStream = newStream
     this._close = close
     this._abort = abort
@@ -152,10 +156,7 @@ export class ConnectionImpl implements Connection {
 
     options.signal = options?.signal ?? AbortSignal.timeout(CLOSE_TIMEOUT)
 
-    try {
-      // fails on node < 15.4
-      setMaxListeners?.(Infinity, options.signal)
-    } catch { }
+    setMaxListeners(Infinity, options.signal)
 
     try {
       log.trace('closing all streams')

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

@@ -1,6 +1,7 @@
-import { setMaxListeners } from 'events'
 import { AbortError, CodeError } from '@libp2p/interface/errors'
+import { setMaxListeners } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
+import { PeerMap } from '@libp2p/peer-collections'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { type Multiaddr, type Resolver, resolvers } from '@multiformats/multiaddr'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
@@ -35,6 +36,7 @@ export interface PendingDialTarget {
 
 export interface DialOptions extends AbortOptions {
   priority?: number
+  force?: boolean
 }
 
 interface PendingDialInternal extends PendingDial {
@@ -48,6 +50,7 @@ interface DialerInit {
   maxParallelDialsPerPeer?: number
   dialTimeout?: number
   resolvers?: Record<string, Resolver>
+  connections?: PeerMap<Connection[]>
 }
 
 const defaultOptions = {
@@ -83,12 +86,14 @@ export class DialQueue {
   private readonly inProgressDialCount?: Metric
   private readonly pendingDialCount?: Metric
   private readonly shutDownController: AbortController
+  private readonly connections: PeerMap<Connection[]>
 
   constructor (components: DialQueueComponents, init: DialerInit = {}) {
     this.addressSorter = init.addressSorter ?? defaultOptions.addressSorter
     this.maxPeerAddrsToDial = init.maxPeerAddrsToDial ?? defaultOptions.maxPeerAddrsToDial
     this.maxParallelDialsPerPeer = init.maxParallelDialsPerPeer ?? defaultOptions.maxParallelDialsPerPeer
     this.dialTimeout = init.dialTimeout ?? defaultOptions.dialTimeout
+    this.connections = init.connections ?? new PeerMap()
 
     this.peerId = components.peerId
     this.peerStore = components.peerStore
@@ -96,10 +101,7 @@ 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 {}
+    setMaxListeners(Infinity, this.shutDownController.signal)
 
     this.pendingDialCount = components.metrics?.registerMetric('libp2p_dialler_pending_dials')
     this.inProgressDialCount = components.metrics?.registerMetric('libp2p_dialler_in_progress_dials')
@@ -190,6 +192,23 @@ export class DialQueue {
       throw err
     }
 
+    // make sure we don't have an existing connection to any of the addresses we
+    // are about to dial
+    let existingConnection = Array.from(this.connections.values()).flat().find(conn => {
+      if (options.force === true) {
+        return false
+      }
+
+      return addrsToDial.find(addr => {
+        return addr.multiaddr.equals(conn.remoteAddr)
+      })
+    })
+
+    if (existingConnection != null) {
+      log('already connected to %a', existingConnection.remoteAddr)
+      return existingConnection
+    }
+
     // ready to dial, all async work finished - make sure we don't have any
     // pending dials in progress for this peer or set of multiaddrs
     const existingDial = this.pendingDials.find(dial => {
@@ -260,7 +279,28 @@ export class DialQueue {
     // let other dials join this one
     this.pendingDials.push(pendingDial)
 
-    return pendingDial.promise
+    const connection = await pendingDial.promise
+
+    // we may have been dialing a multiaddr without a peer id attached but by
+    // this point we have upgraded the connection so the remote peer information
+    // should be available - check again that we don't already have a connection
+    // to the remote multiaddr
+    existingConnection = Array.from(this.connections.values()).flat().find(conn => {
+      if (options.force === true) {
+        return false
+      }
+
+      return conn.id !== connection.id && conn.remoteAddr.equals(connection.remoteAddr)
+    })
+
+    if (existingConnection != null) {
+      log('already connected to %a', existingConnection.remoteAddr)
+      await connection.close()
+      return existingConnection
+    }
+
+    log('connection opened to %a', connection.remoteAddr)
+    return connection
   }
 
   private createDialAbortControllers (userSignal?: AbortSignal): ClearableSignal {

package/src/connection-manager/index.ts

@@ -261,7 +261,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       dialTimeout: init.dialTimeout ?? DIAL_TIMEOUT,
       resolvers: init.resolvers ?? {
         dnsaddr: dnsaddrResolver
-      }
+      },
+      connections: this.connections
     })
   }
 
@@ -505,12 +506,13 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     if (peerId != null && options.force !== true) {
       log('dial %p', peerId)
-      const existingConnections = this.getConnections(peerId)
+      const existingConnection = this.getConnections(peerId)
+        .find(conn => !conn.transient)
 
-      if (existingConnections.length > 0) {
-        log('had an existing connection to %p', peerId)
+      if (existingConnection != null) {
+        log('had an existing non-transient connection to %p', peerId)
 
-        return existingConnections[0]
+        return existingConnection
       }
     }
 

package/src/connection-manager/utils.ts

@@ -1,4 +1,4 @@
-import { setMaxListeners } from 'events'
+import { setMaxListeners } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { type AbortOptions, multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { type ClearableSignal, anySignal } from 'any-signal'
@@ -55,10 +55,7 @@ export function combineSignals (...signals: Array<AbortSignal | undefined>): Cle
 
   for (const sig of signals) {
     if (sig != null) {
-      try {
-        // fails on node < 15.4
-        setMaxListeners?.(Infinity, sig)
-      } catch { }
+      setMaxListeners(Infinity, sig)
       sigs.push(sig)
     }
   }
@@ -66,10 +63,7 @@ export function combineSignals (...signals: Array<AbortSignal | undefined>): Cle
   // let any signal abort the dial
   const signal = anySignal(sigs)
 
-  try {
-    // fails on node < 15.4
-    setMaxListeners?.(Infinity, signal)
-  } catch {}
+  setMaxListeners(Infinity, signal)
 
   return signal
 }

package/src/dcutr/dcutr.ts

@@ -1,12 +1,11 @@
 import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr'
-import { Circuit, IP, DNS } from '@multiformats/multiaddr-matcher'
 import delay from 'delay'
 import { pbStream } from 'it-protobuf-stream'
-import isPrivate from 'private-ip'
 import { codes } from '../errors.js'
 import { HolePunch } from './pb/message.js'
+import { isPublicAndDialable } from './utils.js'
 import { multicodec } from './index.js'
 import type { DCUtRServiceComponents, DCUtRServiceInit } from './index.js'
 import type { Connection, Stream } from '@libp2p/interface/connection'
@@ -72,6 +71,7 @@ export class DefaultDCUtRService implements Startable {
     // register for notifications of when peers that support DCUtR connect
     // nb. requires the identify service to be enabled
     this.topologyId = await this.registrar.register(multicodec, {
+      notifyOnTransient: true,
       onConnect: (peerId, connection) => {
         if (!connection.transient) {
           // the connection is already direct, no upgrade is required
@@ -241,7 +241,7 @@ export class DefaultDCUtRService implements Startable {
         return ma
       })
       .filter(ma => {
-        return this.isPublicAndDialable(ma)
+        return isPublicAndDialable(ma, this.transportManager)
       })
 
     if (publicAddresses.length > 0) {
@@ -365,7 +365,7 @@ export class DefaultDCUtRService implements Startable {
       try {
         const ma = multiaddr(addr)
 
-        if (!this.isPublicAndDialable(ma)) {
+        if (!isPublicAndDialable(ma, this.transportManager)) {
           continue
         }
 
@@ -375,35 +375,4 @@ export class DefaultDCUtRService implements Startable {
 
     return output
   }
-
-  /**
-   * Returns true if the passed multiaddr is public, not relayed and we have a
-   * transport that can dial it
-   */
-  isPublicAndDialable (ma: Multiaddr): boolean {
-    // ignore circuit relay
-    if (Circuit.matches(ma)) {
-      return false
-    }
-
-    // dns addresses are probably public?
-    if (DNS.matches(ma)) {
-      return true
-    }
-
-    // ensure we have only IPv4/IPv6 addresses
-    if (!IP.matches(ma)) {
-      return false
-    }
-
-    const transport = this.transportManager.transportForMultiaddr(ma)
-
-    if (transport == null) {
-      return false
-    }
-
-    const options = ma.toOptions()
-
-    return isPrivate(options.host) === false
-  }
 }

package/src/dcutr/utils.ts

@@ -0,0 +1,33 @@
+import { type Multiaddr } from '@multiformats/multiaddr'
+import { Circuit, IP, DNS } from '@multiformats/multiaddr-matcher'
+import isPrivate from 'private-ip'
+import type { TransportManager } from '@libp2p/interface-internal/src/transport-manager'
+
+/**
+ * Returns true if the passed multiaddr is public, not relayed and we have a
+ * transport that can dial it
+ */
+export function isPublicAndDialable (ma: Multiaddr, transportManager: TransportManager): boolean {
+  // ignore circuit relay
+  if (Circuit.matches(ma)) {
+    return false
+  }
+
+  const transport = transportManager.transportForMultiaddr(ma)
+
+  if (transport == null) {
+    return false
+  }
+
+  // dns addresses are probably public?
+  if (DNS.matches(ma)) {
+    return true
+  }
+
+  // ensure we have only IPv4/IPv6 addresses
+  if (!IP.matches(ma)) {
+    return false
+  }
+
+  return isPrivate(ma.toOptions().host) === false
+}

package/src/fetch/index.ts

@@ -1,5 +1,5 @@
-import { setMaxListeners } from 'events'
 import { CodeError } from '@libp2p/interface/errors'
+import { setMaxListeners } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import first from 'it-first'
 import * as lp from 'it-length-prefixed'
@@ -146,10 +146,7 @@ class DefaultFetchService implements Startable, FetchService {
       log('using default timeout of %d ms', this.init.timeout)
       signal = AbortSignal.timeout(this.init.timeout ?? DEFAULT_TIMEOUT)
 
-      try {
-        // fails on node < 15.4
-        setMaxListeners?.(Infinity, signal)
-      } catch {}
+      setMaxListeners(Infinity, signal)
     }
 
     try {