libp2p 2.8.5 → 2.8.6-aa25d38ab

package/dist/src/version.js

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

package/dist/src/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAA;AAC9B,MAAM,CAAC,MAAM,IAAI,GAAG,WAAW,CAAA"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,iBAAiB,CAAA;AACxC,MAAM,CAAC,MAAM,IAAI,GAAG,WAAW,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "2.8.5",
+  "version": "2.8.6-aa25d38ab",
   "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",
@@ -62,18 +62,6 @@
       "import": "./dist/src/version.js"
     }
   },
-  "eslintConfig": {
-    "extends": "ipfs",
-    "parserOptions": {
-      "project": true,
-      "sourceType": "module"
-    },
-    "ignorePatterns": [
-      "!.aegir.js",
-      "test/ts-use",
-      "*.d.ts"
-    ]
-  },
   "scripts": {
     "clean": "aegir clean",
     "lint": "aegir lint",
@@ -90,48 +78,47 @@
     "test:webkit": "aegir test -t browser -- --browser webkit"
   },
   "dependencies": {
-    "@chainsafe/is-ip": "^2.0.2",
+    "@chainsafe/is-ip": "^2.1.0",
     "@chainsafe/netmask": "^2.0.0",
-    "@libp2p/crypto": "^5.1.1",
-    "@libp2p/interface": "^2.9.0",
-    "@libp2p/interface-internal": "^2.3.11",
-    "@libp2p/logger": "^5.1.15",
-    "@libp2p/multistream-select": "^6.0.22",
-    "@libp2p/peer-collections": "^6.0.27",
-    "@libp2p/peer-id": "^5.1.2",
-    "@libp2p/peer-store": "^11.1.4",
-    "@libp2p/utils": "^6.6.2",
+    "@libp2p/crypto": "5.1.2-aa25d38ab",
+    "@libp2p/interface": "2.10.0-aa25d38ab",
+    "@libp2p/interface-internal": "2.3.12-aa25d38ab",
+    "@libp2p/logger": "5.1.16-aa25d38ab",
+    "@libp2p/multistream-select": "6.0.23-aa25d38ab",
+    "@libp2p/peer-collections": "6.0.28-aa25d38ab",
+    "@libp2p/peer-id": "5.1.3-aa25d38ab",
+    "@libp2p/peer-store": "11.2.0-aa25d38ab",
+    "@libp2p/utils": "6.6.3-aa25d38ab",
     "@multiformats/dns": "^1.0.6",
-    "@multiformats/multiaddr": "^12.3.5",
-    "@multiformats/multiaddr-matcher": "^1.7.0",
+    "@multiformats/multiaddr": "^12.4.0",
+    "@multiformats/multiaddr-matcher": "^1.7.2",
     "any-signal": "^4.1.1",
     "datastore-core": "^10.0.2",
     "interface-datastore": "^8.3.1",
-    "it-byte-stream": "^2.0.1",
-    "it-merge": "^3.0.5",
-    "it-parallel": "^3.0.8",
-    "merge-options": "^3.0.4",
-    "multiformats": "^13.3.1",
+    "it-byte-stream": "^2.0.2",
+    "it-merge": "^3.0.11",
+    "it-parallel": "^3.0.11",
+    "multiformats": "^13.3.4",
     "p-defer": "^4.0.1",
     "p-retry": "^6.2.1",
     "progress-events": "^1.0.1",
     "race-event": "^1.3.0",
-    "race-signal": "^1.1.2",
+    "race-signal": "^1.1.3",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "aegir": "^45.1.1",
+    "aegir": "^47.0.6",
     "delay": "^6.0.0",
-    "it-all": "^3.0.6",
-    "it-drain": "^3.0.7",
+    "it-all": "^3.0.8",
+    "it-drain": "^3.0.9",
     "it-length-prefixed": "^10.0.1",
-    "it-map": "^3.1.1",
+    "it-map": "^3.1.3",
     "it-pair": "^2.0.6",
     "it-stream-types": "^2.0.2",
-    "it-take": "^3.0.6",
+    "it-take": "^3.0.8",
     "p-event": "^6.0.1",
     "p-wait-for": "^5.0.2",
-    "sinon": "^19.0.2",
+    "sinon": "^20.0.0",
     "sinon-ts": "^2.0.0",
     "uint8arraylist": "^2.4.8",
     "wherearewe": "^2.0.1"

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

@@ -151,7 +151,6 @@ export class IPMappings {
 
     for (const mappings of this.mappings.values()) {
       for (const mapping of mappings) {
-        // eslint-disable-next-line max-depth
         if (mapping.externalIp === host) {
           this.log('marking %s to %s IP mapping as verified', mapping.internalIp, mapping.externalIp)
           startingConfidence = mapping.verified

package/src/components.ts

@@ -1,7 +1,7 @@
-import { serviceCapabilities, serviceDependencies } from '@libp2p/interface'
-import { isStartable, type Startable, type Libp2pEvents, type ComponentLogger, type NodeInfo, type ConnectionProtector, type ConnectionGater, type ContentRouting, type TypedEventTarget, type Metrics, type PeerId, type PeerRouting, type PeerStore, type PrivateKey, type Upgrader } from '@libp2p/interface'
+import { serviceCapabilities, serviceDependencies, isStartable } from '@libp2p/interface'
 import { defaultLogger } from '@libp2p/logger'
 import { MissingServiceError, UnmetServiceDependenciesError } from './errors.js'
+import type { Startable, Libp2pEvents, ComponentLogger, NodeInfo, ConnectionProtector, ConnectionGater, ContentRouting, TypedEventTarget, 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'
 import type { Datastore } from 'interface-datastore'

package/src/config.ts

@@ -1,6 +1,6 @@
 import { FaultTolerance, InvalidParametersError } from '@libp2p/interface'
+import { mergeOptions } from '@libp2p/utils/merge-options'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
-import mergeOptions from 'merge-options'
 import type { Libp2pInit } from './index.js'
 import type { ServiceMap } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -25,7 +25,7 @@ const DefaultConfig: Libp2pInit = {
 export async function validateConfig <T extends ServiceMap = Record<string, unknown>> (opts: Libp2pInit<T>): Promise<Libp2pInit<T>> {
   const resultingOptions: Libp2pInit<T> = mergeOptions(DefaultConfig, opts)
 
-  if (resultingOptions.connectionProtector === null && globalThis.process?.env?.LIBP2P_FORCE_PNET != null) { // eslint-disable-line no-undef
+  if (resultingOptions.connectionProtector === null && globalThis.process?.env?.LIBP2P_FORCE_PNET != null) {
     throw new InvalidParametersError('Private network is enforced, but no protector was provided')
   }
 

package/src/connection-manager/index.ts

@@ -1,7 +1,7 @@
 import { ConnectionClosedError, InvalidMultiaddrError, InvalidParametersError, InvalidPeerIdError, NotStartedError, start, stop } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
 import { RateLimiter } from '@libp2p/utils/rate-limiter'
-import { type Multiaddr, type Resolver, multiaddr } from '@multiformats/multiaddr'
+import { multiaddr } from '@multiformats/multiaddr'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import { CustomProgressEvent } from 'progress-events'
 import { getPeerAddress } from '../get-peer.js'
@@ -14,6 +14,7 @@ import type { IpNet } from '@chainsafe/netmask'
 import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions } from '@libp2p/interface'
 import type { ConnectionManager, OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
 import type { JobStatus } from '@libp2p/utils/queue'
+import type { Multiaddr, Resolver } from '@multiformats/multiaddr'
 
 export const DEFAULT_DIAL_PRIORITY = 50
 

package/src/connection-manager/utils.ts

@@ -1,7 +1,8 @@
-import { multiaddr, resolvers, type Multiaddr, type ResolveOptions } from '@multiformats/multiaddr'
+import { multiaddr, resolvers } from '@multiformats/multiaddr'
 import { convertToIpNet } from '@multiformats/multiaddr/convert'
 import type { IpNet } from '@chainsafe/netmask'
 import type { LoggerOptions } from '@libp2p/interface'
+import type { Multiaddr, ResolveOptions } from '@multiformats/multiaddr'
 
 /**
  * Recursively resolve DNSADDR multiaddrs

package/src/content-routing.ts

@@ -104,7 +104,9 @@ export class CompoundContentRouting implements ContentRouting, Startable {
     const seen = new PeerSet()
 
     for await (const peer of merge(
-      ...self.routers.map(router => router.findProviders(key, options))
+      ...self.routers
+        .filter(router => router.findProviders instanceof Function)
+        .map(router => router.findProviders(key, options))
     )) {
       // the peer was yielded by a content router without multiaddrs and we
       // failed to load them
@@ -139,9 +141,12 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       throw new NoContentRoutersError('No content routers available')
     }
 
-    await Promise.all(this.routers.map(async (router) => {
-      await router.provide(key, options)
-    }))
+    await Promise.all(
+      this.routers
+        .filter(router => router.provide instanceof Function)
+        .map(async (router) => {
+          await router.provide(key, options)
+        }))
   }
 
   async cancelReprovide (key: CID, options: AbortOptions = {}): Promise<void> {
@@ -149,9 +154,13 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       throw new NoContentRoutersError('No content routers available')
     }
 
-    await Promise.all(this.routers.map(async (router) => {
-      await router.cancelReprovide(key, options)
-    }))
+    await Promise.all(
+      this.routers
+        .filter(router => router.cancelReprovide instanceof Function)
+        .map(async (router) => {
+          await router.cancelReprovide(key, options)
+        })
+    )
   }
 
   /**
@@ -162,9 +171,13 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       throw new NotStartedError()
     }
 
-    await Promise.all(this.routers.map(async (router) => {
-      await router.put(key, value, options)
-    }))
+    await Promise.all(
+      this.routers
+        .filter(router => router.put instanceof Function)
+        .map(async (router) => {
+          await router.put(key, value, options)
+        })
+    )
   }
 
   /**
@@ -176,8 +189,12 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       throw new NotStartedError()
     }
 
-    return Promise.any(this.routers.map(async (router) => {
-      return router.get(key, options)
-    }))
+    return Promise.any(
+      this.routers
+        .filter(router => router.get instanceof Function)
+        .map(async (router) => {
+          return router.get(key, options)
+        })
+    )
   }
 }

package/src/libp2p.ts

@@ -4,7 +4,7 @@ import { defaultLogger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { persistentPeerStore } from '@libp2p/peer-store'
-import { isMultiaddr, type Multiaddr } from '@multiformats/multiaddr'
+import { isMultiaddr } from '@multiformats/multiaddr'
 import { MemoryDatastore } from 'datastore-core/memory'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
@@ -24,6 +24,7 @@ import * as pkg from './version.js'
 import type { Components } from './components.js'
 import type { Libp2p as Libp2pInterface, Libp2pInit } from './index.js'
 import type { PeerRouting, ContentRouting, Libp2pEvents, PendingDial, ServiceMap, AbortOptions, ComponentLogger, Logger, Connection, NewStreamOptions, Stream, Metrics, PeerId, PeerInfo, PeerStore, Topology, Libp2pStatus, IsDialableOptions, DialOptions, PublicKey, Ed25519PeerId, Secp256k1PeerId, RSAPublicKey, RSAPeerId, URLPeerId, Ed25519PublicKey, Secp256k1PublicKey, StreamHandler, StreamHandlerOptions } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter<Libp2pEvents> implements Libp2pInterface<T> {
   public peerId: PeerId

package/src/peer-routing.ts

@@ -72,13 +72,15 @@ export class DefaultPeerRouting implements PeerRouting {
 
     const self = this
     const source = merge(
-      ...this.routers.map(router => (async function * () {
-        try {
-          yield await router.findPeer(id, options)
-        } catch (err) {
-          self.log.error(err)
-        }
-      })())
+      ...this.routers
+        .filter(router => router.findPeer instanceof Function)
+        .map(router => (async function * () {
+          try {
+            yield await router.findPeer(id, options)
+          } catch (err) {
+            self.log.error(err)
+          }
+        })())
     )
 
     for await (const peer of source) {
@@ -113,7 +115,9 @@ export class DefaultPeerRouting implements PeerRouting {
     for await (const peer of parallel(
       async function * () {
         const source = merge(
-          ...self.routers.map(router => router.getClosestPeers(key, options))
+          ...self.routers
+            .filter(router => router.getClosestPeers instanceof Function)
+            .map(router => router.getClosestPeers(key, options))
         )
 
         for await (let peer of source) {

package/src/random-walk.ts

@@ -1,11 +1,12 @@
 import { randomBytes } from '@libp2p/crypto'
 import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { anySignal } from 'any-signal'
-import pDefer, { type DeferredPromise } from 'p-defer'
+import pDefer from 'p-defer'
 import { raceEvent } from 'race-event'
 import { raceSignal } from 'race-signal'
 import type { AbortOptions, ComponentLogger, Logger, PeerInfo, PeerRouting, Startable } from '@libp2p/interface'
 import type { RandomWalk as RandomWalkInterface } from '@libp2p/interface-internal'
+import type { DeferredPromise } from 'p-defer'
 
 export interface RandomWalkComponents {
   peerRouting: PeerRouting

package/src/registrar.ts

@@ -1,5 +1,5 @@
 import { InvalidParametersError } from '@libp2p/interface'
-import merge from 'merge-options'
+import { mergeOptions } from '@libp2p/utils/merge-options'
 import * as errorsJs from './errors.js'
 import type { IdentifyResult, Libp2pEvents, Logger, PeerUpdate, TypedEventTarget, PeerId, PeerStore, Topology, StreamHandler, StreamHandlerRecord, StreamHandlerOptions } from '@libp2p/interface'
 import type { Registrar as RegistrarInterface } from '@libp2p/interface-internal'
@@ -77,7 +77,7 @@ export class Registrar implements RegistrarInterface {
       throw new errorsJs.DuplicateProtocolHandlerError(`Handler already registered for protocol ${protocol}`)
     }
 
-    const options = merge.bind({ ignoreUndefined: true })({
+    const options = mergeOptions.bind({ ignoreUndefined: true })({
       maxInboundStreams: DEFAULT_MAX_INBOUND_STREAMS,
       maxOutboundStreams: DEFAULT_MAX_OUTBOUND_STREAMS
     }, opts)

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.8.5'
+export const version = '2.8.6-aa25d38ab'
 export const name = 'js-libp2p'

package/dist/typedoc-urls.json

@@ -1,21 +0,0 @@
-{
-  "AddressFilter": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.AddressFilter.html",
-  "AddressManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.AddressManagerInit.html",
-  "ConnectionManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionManagerInit.html",
-  "ConnectionMonitorInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionMonitorInit.html",
-  "Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  ".:Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  "TransportManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.TransportManagerInit.html",
-  "Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  ".:Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  "ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  ".:ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  "createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  ".:createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  "userAgent": "https://libp2p.github.io/js-libp2p/functions/libp2p.user_agent.userAgent.html",
-  "./user-agent:userAgent": "https://libp2p.github.io/js-libp2p/functions/libp2p.user_agent.userAgent.html",
-  "name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "./version:name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html",
-  "./version:version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html"
-}