libp2p 3.2.0 → 3.2.1

package/dist/src/registrar.js

@@ -1,6 +1,6 @@
 import { InvalidParametersError } from '@libp2p/interface';
 import { trackedMap } from '@libp2p/utils';
-import { DuplicateProtocolHandlerError, UnhandledProtocolError } from './errors.js';
+import { DuplicateProtocolHandlerError, UnhandledProtocolError } from "./errors.js";
 export const DEFAULT_MAX_INBOUND_STREAMS = 32;
 export const DEFAULT_MAX_OUTBOUND_STREAMS = 64;
 /**

package/dist/src/transport-manager.js

@@ -2,7 +2,7 @@ import { FaultTolerance, InvalidParametersError, NotStartedError } from '@libp2p
 import { trackedMap } from '@libp2p/utils';
 import { IP4, IP6 } from '@multiformats/multiaddr-matcher';
 import { CustomProgressEvent } from 'progress-events';
-import { TransportUnavailableError, UnsupportedListenAddressError, UnsupportedListenAddressesError } from './errors.js';
+import { TransportUnavailableError, UnsupportedListenAddressError, UnsupportedListenAddressesError } from "./errors.js";
 export class DefaultTransportManager {
     log;
     components;

package/dist/src/upgrader.js

@@ -7,9 +7,9 @@ import { anySignal } from 'any-signal';
 import { setMaxListeners } from 'main-event';
 import { CustomProgressEvent } from 'progress-events';
 import { raceSignal } from 'race-signal';
-import { PROTOCOL_NEGOTIATION_TIMEOUT, INBOUND_UPGRADE_TIMEOUT, CONNECTION_CLOSE_TIMEOUT } from './connection-manager/constants.js';
-import { createConnection } from './connection.js';
-import { ConnectionDeniedError, ConnectionInterceptedError, EncryptionFailedError, MuxerUnavailableError } from './errors.js';
+import { PROTOCOL_NEGOTIATION_TIMEOUT, INBOUND_UPGRADE_TIMEOUT, CONNECTION_CLOSE_TIMEOUT } from "./connection-manager/constants.js";
+import { createConnection } from "./connection.js";
+import { ConnectionDeniedError, ConnectionInterceptedError, EncryptionFailedError, MuxerUnavailableError } from "./errors.js";
 export class Upgrader {
     components;
     connectionEncrypters;

package/dist/src/user-agent.browser.js

@@ -1,4 +1,4 @@
-import * as pkg from './version.js';
+import * as pkg from "./version.js";
 export function userAgent(name, version) {
     return `${name ?? pkg.name}/${version ?? pkg.version} browser/${globalThis.navigator.userAgent}`;
 }

package/dist/src/user-agent.js

@@ -1,5 +1,5 @@
 import process from 'node:process';
-import * as pkg from './version.js';
+import * as pkg from "./version.js";
 export function userAgent(name, version) {
     let platform = 'node';
     let platformVersion = process.versions.node;

package/dist/src/user-agent.react-native.js

@@ -1,5 +1,5 @@
 import { Platform } from 'react-native';
-import * as pkg from './version.js';
+import * as pkg from "./version.js";
 export function userAgent(name, version) {
     return `${name ?? pkg.name}/${version ?? pkg.version} react-native/${Platform.OS}-${`${Platform.Version}`.replaceAll('v', '')}`;
 }

package/dist/src/version.d.ts

@@ -1,3 +1,3 @@
-export declare const version = "3.2.0";
+export declare const version = "3.2.1";
 export declare const name = "js-libp2p";
 //# sourceMappingURL=version.d.ts.map

package/dist/src/version.js

@@ -1,3 +1,3 @@
-export const version = '3.2.0';
+export const version = '3.2.1';
 export const name = 'js-libp2p';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "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/main/packages/libp2p#readme",
@@ -50,16 +50,19 @@
   "exports": {
     ".": {
       "types": "./dist/src/index.d.ts",
-      "import": "./dist/src/index.js"
+      "import": "./dist/src/index.js",
+      "module-sync": "./dist/src/index.js"
     },
     "./user-agent": {
       "types": "./dist/src/user-agent.d.ts",
       "browser": "./dist/src/user-agent.browser.js",
-      "import": "./dist/src/user-agent.js"
+      "import": "./dist/src/user-agent.js",
+      "module-sync": "./dist/src/user-agent.js"
     },
     "./version": {
       "types": "./dist/src/version.d.ts",
-      "import": "./dist/src/version.js"
+      "import": "./dist/src/version.js",
+      "module-sync": "./dist/src/version.js"
     }
   },
   "scripts": {
@@ -80,15 +83,15 @@
   "dependencies": {
     "@chainsafe/is-ip": "^2.1.0",
     "@chainsafe/netmask": "^2.0.0",
-    "@libp2p/crypto": "^5.1.15",
-    "@libp2p/interface": "^3.2.0",
-    "@libp2p/interface-internal": "^3.1.0",
-    "@libp2p/logger": "^6.2.4",
-    "@libp2p/multistream-select": "^7.0.15",
-    "@libp2p/peer-collections": "^7.0.15",
-    "@libp2p/peer-id": "^6.0.6",
-    "@libp2p/peer-store": "^12.0.15",
-    "@libp2p/utils": "^7.0.15",
+    "@libp2p/crypto": "^5.1.16",
+    "@libp2p/interface": "^3.2.1",
+    "@libp2p/interface-internal": "^3.1.1",
+    "@libp2p/logger": "^6.2.5",
+    "@libp2p/multistream-select": "^7.0.16",
+    "@libp2p/peer-collections": "^7.0.16",
+    "@libp2p/peer-id": "^6.0.7",
+    "@libp2p/peer-store": "^12.0.16",
+    "@libp2p/utils": "^7.0.16",
     "@multiformats/dns": "^1.0.6",
     "@multiformats/multiaddr": "^13.0.1",
     "@multiformats/multiaddr-matcher": "^3.0.1",
@@ -101,7 +104,7 @@
     "multiformats": "^13.4.0",
     "p-defer": "^4.0.1",
     "p-event": "^7.0.0",
-    "p-retry": "^7.0.0",
+    "p-retry": "^8.0.0",
     "progress-events": "^1.1.0",
     "race-signal": "^2.0.0",
     "uint8arrays": "^5.1.0"

package/src/address-manager/dns-mappings.ts

@@ -1,6 +1,6 @@
 import { getNetConfig, isNetworkAddress, isPrivateIp, trackedMap } from '@libp2p/utils'
 import { CODE_SNI, CODE_TLS, multiaddr } from '@multiformats/multiaddr'
-import type { AddressManagerComponents, AddressManagerInit } from './index.js'
+import type { AddressManagerComponents, AddressManagerInit } from './index.ts'
 import type { Logger } from '@libp2p/interface'
 import type { NodeAddress } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'

package/src/address-manager/index.ts

@@ -4,10 +4,10 @@ import { peerIdFromString } from '@libp2p/peer-id'
 import { debounce, createScalableCuckooFilter, isPrivateIp, getNetConfig, isNetworkAddress, isLoopback } from '@libp2p/utils'
 import { CODE_P2P, multiaddr } from '@multiformats/multiaddr'
 import { QUIC_V1, TCP, WebSockets, WebSocketsSecure } from '@multiformats/multiaddr-matcher'
-import { DNSMappings } from './dns-mappings.js'
-import { IPMappings } from './ip-mappings.js'
-import { ObservedAddresses } from './observed-addresses.js'
-import { TransportAddresses } from './transport-addresses.js'
+import { DNSMappings } from './dns-mappings.ts'
+import { IPMappings } from './ip-mappings.ts'
+import { ObservedAddresses } from './observed-addresses.ts'
+import { TransportAddresses } from './transport-addresses.ts'
 import type { ComponentLogger, Libp2pEvents, Logger, PeerId, PeerStore, Metrics } from '@libp2p/interface'
 import type { AddressManager as AddressManagerInterface, TransportManager, NodeAddress, ConfirmAddressOptions } from '@libp2p/interface-internal'
 import type { Filter } from '@libp2p/utils'

package/src/address-manager/ip-mappings.ts

@@ -1,7 +1,7 @@
 import { isIPv4 } from '@chainsafe/is-ip'
 import { getNetConfig, isNetworkAddress, trackedMap } from '@libp2p/utils'
 import { CODE_IP4, CODE_IP6, multiaddr } from '@multiformats/multiaddr'
-import type { AddressManagerComponents, AddressManagerInit } from './index.js'
+import type { AddressManagerComponents, AddressManagerInit } from './index.ts'
 import type { Logger } from '@libp2p/interface'
 import type { NodeAddress } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'

package/src/address-manager/observed-addresses.ts

@@ -1,6 +1,6 @@
 import { isLinkLocal, isPrivate, trackedMap } from '@libp2p/utils'
 import { multiaddr } from '@multiformats/multiaddr'
-import type { AddressManagerComponents, AddressManagerInit } from './index.js'
+import type { AddressManagerComponents, AddressManagerInit } from './index.ts'
 import type { Logger } from '@libp2p/interface'
 import type { NodeAddress } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'

package/src/address-manager/transport-addresses.ts

@@ -1,5 +1,5 @@
 import { getNetConfig, isNetworkAddress, isPrivate, trackedMap } from '@libp2p/utils'
-import type { AddressManagerComponents, AddressManagerInit } from './index.js'
+import type { AddressManagerComponents, AddressManagerInit } from './index.ts'
 import type { Logger } from '@libp2p/interface'
 import type { NodeAddress } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'

package/src/components.ts

@@ -1,6 +1,6 @@
 import { serviceCapabilities, serviceDependencies, isStartable } from '@libp2p/interface'
 import { defaultLogger } from '@libp2p/logger'
-import { MissingServiceError, UnmetServiceDependenciesError } from './errors.js'
+import { MissingServiceError, UnmetServiceDependenciesError } from './errors.ts'
 import type { Startable, Libp2pEvents, ComponentLogger, NodeInfo, ConnectionProtector, ConnectionGater, ContentRouting, Metrics, PeerId, PeerRouting, PeerStore, PrivateKey, Upgrader } from '@libp2p/interface'
 import type { AddressManager, ConnectionManager, RandomWalk, Registrar, TransportManager } from '@libp2p/interface-internal'
 import type { DNS } from '@multiformats/dns'

package/src/config.ts

@@ -1,5 +1,5 @@
 import { InvalidParametersError } from '@libp2p/interface'
-import type { Libp2pInit } from './index.js'
+import type { Libp2pInit } from './index.ts'
 import type { ServiceMap } from '@libp2p/interface'
 
 export async function validateConfig <T extends ServiceMap = Record<string, unknown>> (opts: Libp2pInit<T>): Promise<Libp2pInit<T>> {

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

@@ -1,6 +1,6 @@
 import { PeerMap } from '@libp2p/peer-collections'
 import { getNetConfig, isNetworkAddress } from '@libp2p/utils'
-import { multiaddrToIpNet, safelyCloseConnectionIfUnused } from './utils.js'
+import { multiaddrToIpNet, safelyCloseConnectionIfUnused } from './utils.ts'
 import type { IpNet } from '@chainsafe/netmask'
 import type { Libp2pEvents, Logger, ComponentLogger, PeerStore, Connection } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'

package/src/connection-manager/constants.browser.ts

@@ -1,4 +1,4 @@
-export * from './constants.defaults.js'
+export * from './constants.defaults.ts'
 
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionManagerInit.html#maxConnections

package/src/connection-manager/constants.defaults.ts

@@ -3,6 +3,11 @@
  */
 export const DIAL_TIMEOUT = 10_000
 
+/**
+ * @see https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionManagerInit.html#addressDialTimeout
+ */
+export const ADDRESS_DIAL_TIMEOUT = 6_000
+
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionManagerInit.html#connectionCloseTimeout
  */

package/src/connection-manager/constants.ts

@@ -1,4 +1,4 @@
-export * from './constants.defaults.js'
+export * from './constants.defaults.ts'
 
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionManagerInit.html#maxConnections

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

@@ -10,18 +10,19 @@ import { CustomProgressEvent } from 'progress-events'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { DialDeniedError, NoValidAddressesError } from '../errors.js'
 import { getPeerAddress } from '../get-peer.js'
-import { defaultAddressSorter } from './address-sorter.js'
+import { defaultAddressSorter } from './address-sorter.ts'
 import {
+  ADDRESS_DIAL_TIMEOUT,
   DIAL_TIMEOUT,
   MAX_PARALLEL_DIALS,
   MAX_PEER_ADDRS_TO_DIAL,
   LAST_DIAL_FAILURE_KEY,
   MAX_DIAL_QUEUE_LENGTH,
   LAST_DIAL_SUCCESS_KEY
-} from './constants.js'
-import { resolveMultiaddr, dnsaddrResolver } from './resolvers/index.js'
+} from './constants.ts'
+import { DEFAULT_DIAL_PRIORITY } from './index.ts'
+import { resolveMultiaddr, dnsaddrResolver } from './resolvers/index.ts'
 import { findExistingConnection } from './utils.ts'
-import { DEFAULT_DIAL_PRIORITY } from './index.js'
 import type { AddressSorter, ComponentLogger, Logger, Connection, ConnectionGater, Metrics, PeerId, Address, PeerStore, PeerRouting, IsDialableOptions, OpenConnectionProgressEvents, MultiaddrResolver, DialTarget } from '@libp2p/interface'
 import type { OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
 import type { PriorityQueueJobOptions } from '@libp2p/utils'
@@ -45,6 +46,7 @@ interface DialerInit {
   maxDialQueueLength?: number
   maxPeerAddrsToDial?: number
   dialTimeout?: number
+  addressDialTimeout?: number
   resolvers?: Record<string, MultiaddrResolver>
   connections?: PeerMap<Connection[]>
 }
@@ -54,6 +56,7 @@ const defaultOptions = {
   maxDialQueueLength: MAX_DIAL_QUEUE_LENGTH,
   maxPeerAddrsToDial: MAX_PEER_ADDRS_TO_DIAL,
   dialTimeout: DIAL_TIMEOUT,
+  addressDialTimeout: ADDRESS_DIAL_TIMEOUT,
   resolvers: {
     dnsaddr: dnsaddrResolver
   }
@@ -77,6 +80,7 @@ export class DialQueue {
   private readonly maxPeerAddrsToDial: number
   private readonly maxDialQueueLength: number
   private readonly dialTimeout: number
+  private readonly addressDialTimeout: number
   private shutDownController: AbortController
   private readonly connections: PeerMap<Connection[]>
   private readonly log: Logger
@@ -87,6 +91,7 @@ export class DialQueue {
     this.maxPeerAddrsToDial = init.maxPeerAddrsToDial ?? defaultOptions.maxPeerAddrsToDial
     this.maxDialQueueLength = init.maxDialQueueLength ?? defaultOptions.maxDialQueueLength
     this.dialTimeout = init.dialTimeout ?? defaultOptions.dialTimeout
+    this.addressDialTimeout = init.addressDialTimeout ?? defaultOptions.addressDialTimeout
     this.connections = init.connections ?? new PeerMap()
     this.log = components.logger.forComponent('libp2p:connection-manager:dial-queue')
     this.components = components
@@ -279,11 +284,17 @@ export class DialQueue {
 
         dialed++
 
+        // create a per-address signal so a single slow/unreachable address
+        // cannot consume the entire dialTimeout budget when multiple addresses
+        // are available - the outer batch signal can still abort everything
+        const addressSignal = anySignal([signal, AbortSignal.timeout(this.addressDialTimeout)])
+        setMaxListeners(Infinity, addressSignal)
+
         try {
           // try to dial the address
           const conn = await this.components.transportManager.dial(address.multiaddr, {
             ...options,
-            signal
+            signal: addressSignal
           })
 
           this.log('dial to %a succeeded', address.multiaddr)
@@ -323,12 +334,16 @@ export class DialQueue {
             }
           }
 
-          // the user/dial timeout/shutdown controller signal aborted
+          // the user/batch timeout/shutdown controller signal aborted - stop
+          // trying further addresses for this peer
           if (signal.aborted) {
             throw new TimeoutError(err.message)
           }
 
           errors.push(err)
+        } finally {
+          // unregister listeners on parent signals immediately to avoid leaks
+          addressSignal.clear()
         }
       }
     }
@@ -473,7 +488,7 @@ export class DialQueue {
 
     // make sure we actually have some addresses to dial
     if (dedupedMultiaddrs.length === 0) {
-      throw new NoValidAddressesError('The dial request has no valid addresses')
+      throw new NoValidAddressesError(`The dial request has no valid addresses for peer: ${peerId?.toString() ?? 'unknown peer'}`)
     }
 
     const gatedAddrs: Address[] = []
@@ -490,7 +505,7 @@ export class DialQueue {
 
     // make sure we actually have some addresses to dial
     if (sortedGatedAddrs.length === 0) {
-      throw new DialDeniedError('The connection gater denied all addresses in the dial request')
+      throw new DialDeniedError(`The connection gater denied all addresses in the dial request for peer: ${peerId?.toString() ?? 'unknown peer'}`)
     }
 
     this.log.trace('addresses for %p before filtering', peerId ?? 'unknown peer', resolvedAddresses.map(({ multiaddr }) => multiaddr.toString()))

package/src/connection-manager/index.ts

@@ -5,12 +5,12 @@ import { multiaddr } from '@multiformats/multiaddr'
 import { pEvent } from 'p-event'
 import { CustomProgressEvent } from 'progress-events'
 import { getPeerAddress } from '../get-peer.js'
-import { ConnectionPruner } from './connection-pruner.js'
-import { DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_DIAL_QUEUE_LENGTH, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL } from './constants.js'
-import { DialQueue } from './dial-queue.js'
-import { ReconnectQueue } from './reconnect-queue.js'
+import { ConnectionPruner } from './connection-pruner.ts'
+import { ADDRESS_DIAL_TIMEOUT, DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_DIAL_QUEUE_LENGTH, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL } from './constants.ts'
+import { DialQueue } from './dial-queue.ts'
+import { ReconnectQueue } from './reconnect-queue.ts'
 import { dnsaddrResolver } from './resolvers/index.ts'
-import { findExistingConnection, multiaddrToIpNet } from './utils.js'
+import { findExistingConnection, multiaddrToIpNet } from './utils.ts'
 import type { IpNet } from '@chainsafe/netmask'
 import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions, MultiaddrResolver, Stream, NewStreamOptions, DialTarget } from '@libp2p/interface'
 import type { ConnectionManager, OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
@@ -66,6 +66,16 @@ export interface ConnectionManagerInit {
    */
   dialTimeout?: number
 
+  /**
+   * How long a single address dial attempt is allowed to take before the
+   * dialer moves on to the next address. This prevents a single slow or
+   * unreachable address from consuming the entire `dialTimeout` budget when
+   * multiple addresses are available for a peer.
+   *
+   * @default 6_000
+   */
+  addressDialTimeout?: number
+
   /**
    * How many ms to wait when closing a connection if an abort signal is not
    * passed
@@ -261,6 +271,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       maxDialQueueLength: init.maxDialQueueLength ?? MAX_DIAL_QUEUE_LENGTH,
       maxPeerAddrsToDial: init.maxPeerAddrsToDial ?? MAX_PEER_ADDRS_TO_DIAL,
       dialTimeout: init.dialTimeout ?? DIAL_TIMEOUT,
+      addressDialTimeout: init.addressDialTimeout ?? ADDRESS_DIAL_TIMEOUT,
       resolvers: init.resolvers ?? {
         dnsaddr: dnsaddrResolver
       },

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

@@ -1,7 +1,7 @@
 import { KEEP_ALIVE } from '@libp2p/interface'
 import { PeerQueue } from '@libp2p/utils'
 import pRetry from 'p-retry'
-import { MAX_PARALLEL_RECONNECTS } from './constants.js'
+import { MAX_PARALLEL_RECONNECTS } from './constants.ts'
 import type { ComponentLogger, Libp2pEvents, Logger, Metrics, Peer, PeerId, PeerStore, Startable } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
 import type { TypedEventTarget } from 'main-event'

package/src/connection-manager/resolvers/index.ts

@@ -56,4 +56,4 @@ export async function resolveMultiaddr (address: Multiaddr, resolvers: Record<st
   return output
 }
 
-export { dnsaddrResolver } from './dnsaddr.js'
+export { dnsaddrResolver } from './dnsaddr.ts'

package/src/content-routing.ts

@@ -2,7 +2,7 @@ import { NotStartedError } from '@libp2p/interface'
 import { PeerSet } from '@libp2p/peer-collections'
 import merge from 'it-merge'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { NoContentRoutersError } from './errors.js'
+import { NoContentRoutersError } from './errors.ts'
 import type { AbortOptions, ComponentLogger, ContentRouting, Metrics, PeerRouting, PeerStore, Provider, RoutingOptions, Startable } from '@libp2p/interface'
 import type { CID } from 'multiformats/cid'
 

package/src/index.ts

@@ -16,13 +16,13 @@
 
 import { generateKeyPair } from '@libp2p/crypto/keys'
 import { peerIdFromPrivateKey } from '@libp2p/peer-id'
-import { validateConfig } from './config.js'
-import { Libp2p as Libp2pClass } from './libp2p.js'
-import type { AddressManagerInit, AddressFilter } from './address-manager/index.js'
-import type { Components } from './components.js'
-import type { ConnectionManagerInit } from './connection-manager/index.js'
-import type { ConnectionMonitorInit } from './connection-monitor.js'
-import type { TransportManagerInit } from './transport-manager.js'
+import { validateConfig } from './config.ts'
+import { Libp2p as Libp2pClass } from './libp2p.ts'
+import type { AddressManagerInit, AddressFilter } from './address-manager/index.ts'
+import type { Components } from './components.ts'
+import type { ConnectionManagerInit } from './connection-manager/index.ts'
+import type { ConnectionMonitorInit } from './connection-monitor.ts'
+import type { TransportManagerInit } from './transport-manager.ts'
 import type { Libp2p, ServiceMap, ComponentLogger, NodeInfo, ConnectionProtector, ConnectionEncrypter, ConnectionGater, ContentRouting, Metrics, PeerDiscovery, PeerRouting, StreamMuxerFactory, Transport, PrivateKey } from '@libp2p/interface'
 import type { PersistentPeerStoreInit } from '@libp2p/peer-store'
 import type { DNS } from '@multiformats/dns'

package/src/libp2p.ts

@@ -9,21 +9,21 @@ import { MemoryDatastore } from 'datastore-core/memory'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { AddressManager } from './address-manager/index.js'
-import { checkServiceDependencies, defaultComponents } from './components.js'
-import { connectionGater } from './config/connection-gater.js'
-import { DefaultConnectionManager } from './connection-manager/index.js'
-import { ConnectionMonitor } from './connection-monitor.js'
-import { CompoundContentRouting } from './content-routing.js'
-import { DefaultPeerRouting } from './peer-routing.js'
-import { RandomWalk } from './random-walk.js'
-import { Registrar } from './registrar.js'
-import { DefaultTransportManager } from './transport-manager.js'
-import { Upgrader } from './upgrader.js'
-import { userAgent } from './user-agent.js'
-import * as pkg from './version.js'
-import type { Components } from './components.js'
-import type { Libp2p as Libp2pInterface, Libp2pInit } from './index.js'
+import { AddressManager } from './address-manager/index.ts'
+import { checkServiceDependencies, defaultComponents } from './components.ts'
+import { connectionGater } from './config/connection-gater.ts'
+import { DefaultConnectionManager } from './connection-manager/index.ts'
+import { ConnectionMonitor } from './connection-monitor.ts'
+import { CompoundContentRouting } from './content-routing.ts'
+import { DefaultPeerRouting } from './peer-routing.ts'
+import { RandomWalk } from './random-walk.ts'
+import { Registrar } from './registrar.ts'
+import { DefaultTransportManager } from './transport-manager.ts'
+import { Upgrader } from './upgrader.ts'
+import { userAgent } from './user-agent.ts'
+import * as pkg from './version.ts'
+import type { Components } from './components.ts'
+import type { Libp2p as Libp2pInterface, Libp2pInit } from './index.ts'
 import type { PeerRouting, ContentRouting, Libp2pEvents, PendingDial, ServiceMap, AbortOptions, ComponentLogger, Logger, Connection, Stream, Metrics, PeerId, PeerInfo, PeerStore, Topology, Libp2pStatus, IsDialableOptions, DialOptions, PublicKey, Ed25519PeerId, Secp256k1PeerId, RSAPublicKey, RSAPeerId, URLPeerId, Ed25519PublicKey, Secp256k1PublicKey, StreamHandler, StreamHandlerOptions, StreamMiddleware, DialTarget, DialProtocolOptions } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 

package/src/peer-routing.ts

@@ -3,7 +3,7 @@ import { createScalableCuckooFilter } from '@libp2p/utils'
 import merge from 'it-merge'
 import parallel from 'it-parallel'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { NoPeerRoutersError, QueriedForSelfError } from './errors.js'
+import { NoPeerRoutersError, QueriedForSelfError } from './errors.ts'
 import type { Logger, Metrics, PeerId, PeerInfo, PeerRouting, PeerStore, RoutingOptions } from '@libp2p/interface'
 import type { ComponentLogger } from '@libp2p/logger'
 

package/src/registrar.ts

@@ -1,6 +1,6 @@
 import { InvalidParametersError } from '@libp2p/interface'
 import { trackedMap } from '@libp2p/utils'
-import { DuplicateProtocolHandlerError, UnhandledProtocolError } from './errors.js'
+import { DuplicateProtocolHandlerError, UnhandledProtocolError } from './errors.ts'
 import type { IdentifyResult, Libp2pEvents, Logger, PeerUpdate, PeerId, PeerStore, Topology, StreamHandler, StreamHandlerRecord, StreamHandlerOptions, AbortOptions, Metrics, StreamMiddleware } from '@libp2p/interface'
 import type { Registrar as RegistrarInterface } from '@libp2p/interface-internal'
 import type { ComponentLogger } from '@libp2p/logger'

package/src/transport-manager.ts

@@ -2,7 +2,7 @@ import { FaultTolerance, InvalidParametersError, NotStartedError } from '@libp2p
 import { trackedMap } from '@libp2p/utils'
 import { IP4, IP6 } from '@multiformats/multiaddr-matcher'
 import { CustomProgressEvent } from 'progress-events'
-import { TransportUnavailableError, UnsupportedListenAddressError, UnsupportedListenAddressesError } from './errors.js'
+import { TransportUnavailableError, UnsupportedListenAddressError, UnsupportedListenAddressesError } from './errors.ts'
 import type { Libp2pEvents, ComponentLogger, Logger, Connection, Metrics, Startable, Listener, Transport, Upgrader } from '@libp2p/interface'
 import type { AddressManager, TransportManager, TransportManagerDialOptions } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'

package/src/upgrader.ts

@@ -7,9 +7,9 @@ import { anySignal } from 'any-signal'
 import { setMaxListeners } from 'main-event'
 import { CustomProgressEvent } from 'progress-events'
 import { raceSignal } from 'race-signal'
-import { PROTOCOL_NEGOTIATION_TIMEOUT, INBOUND_UPGRADE_TIMEOUT, CONNECTION_CLOSE_TIMEOUT } from './connection-manager/constants.js'
-import { createConnection } from './connection.js'
-import { ConnectionDeniedError, ConnectionInterceptedError, EncryptionFailedError, MuxerUnavailableError } from './errors.js'
+import { PROTOCOL_NEGOTIATION_TIMEOUT, INBOUND_UPGRADE_TIMEOUT, CONNECTION_CLOSE_TIMEOUT } from './connection-manager/constants.ts'
+import { createConnection } from './connection.ts'
+import { ConnectionDeniedError, ConnectionInterceptedError, EncryptionFailedError, MuxerUnavailableError } from './errors.ts'
 import type { Libp2pEvents, AbortOptions, ComponentLogger, MultiaddrConnection, Connection, ConnectionProtector, ConnectionEncrypter, ConnectionGater, Metrics, PeerId, PeerStore, StreamMuxerFactory, Upgrader as UpgraderInterface, UpgraderOptions, ConnectionLimits, CounterGroup, ClearableSignal, MessageStream, SecuredConnection, StreamMuxer, UpgraderWithoutEncryptionOptions, SecureConnectionOptions } from '@libp2p/interface'
 import type { ConnectionManager, Registrar } from '@libp2p/interface-internal'
 import type { TypedEventTarget } from 'main-event'

package/src/user-agent.browser.ts

@@ -1,4 +1,4 @@
-import * as pkg from './version.js'
+import * as pkg from './version.ts'
 
 export function userAgent (name?: string, version?: string): string {
   return `${name ?? pkg.name}/${version ?? pkg.version} browser/${globalThis.navigator.userAgent}`

package/src/user-agent.react-native.ts

@@ -1,5 +1,5 @@
 import { Platform } from 'react-native'
-import * as pkg from './version.js'
+import * as pkg from './version.ts'
 
 export function userAgent (name?: string, version?: string): string {
   return `${name ?? pkg.name}/${version ?? pkg.version} react-native/${Platform.OS}-${`${Platform.Version}`.replaceAll('v', '')}`

package/src/user-agent.ts

@@ -1,5 +1,5 @@
 import process from 'node:process'
-import * as pkg from './version.js'
+import * as pkg from './version.ts'
 
 export function userAgent (name?: string, version?: string): string {
   let platform = 'node'

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '3.2.0'
+export const version = '3.2.1'
 export const name = 'js-libp2p'