libp2p 0.46.15 → 0.46.16-346ff5a2

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,SAAS,CAAA;AAChC,MAAM,CAAC,MAAM,IAAI,GAAG,QAAQ,CAAA"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,kBAAkB,CAAA;AACzC,MAAM,CAAC,MAAM,IAAI,GAAG,QAAQ,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "0.46.15",
+  "version": "0.46.16-346ff5a2",
   "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.5",
-    "@libp2p/interface": "^0.1.3",
-    "@libp2p/interface-internal": "^0.1.6",
-    "@libp2p/keychain": "^3.0.5",
-    "@libp2p/logger": "^3.0.3",
-    "@libp2p/multistream-select": "^4.0.3",
-    "@libp2p/peer-collections": "^4.0.5",
-    "@libp2p/peer-id": "^3.0.3",
-    "@libp2p/peer-id-factory": "^3.0.5",
-    "@libp2p/peer-record": "^6.0.6",
-    "@libp2p/peer-store": "^9.0.6",
-    "@libp2p/utils": "^4.0.4",
+    "@libp2p/crypto": "2.0.6-346ff5a2",
+    "@libp2p/interface": "0.1.4-346ff5a2",
+    "@libp2p/interface-internal": "0.1.7-346ff5a2",
+    "@libp2p/keychain": "3.0.6-346ff5a2",
+    "@libp2p/logger": "3.0.4-346ff5a2",
+    "@libp2p/multistream-select": "4.0.4-346ff5a2",
+    "@libp2p/peer-collections": "4.0.6-346ff5a2",
+    "@libp2p/peer-id": "3.0.4-346ff5a2",
+    "@libp2p/peer-id-factory": "3.0.6-346ff5a2",
+    "@libp2p/peer-record": "6.0.7-346ff5a2",
+    "@libp2p/peer-store": "9.0.7-346ff5a2",
+    "@libp2p/utils": "4.0.5-346ff5a2",
     "@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.8",
+    "@libp2p/bootstrap": "9.0.9-346ff5a2",
     "@libp2p/daemon-client": "^7.0.0",
     "@libp2p/daemon-server": "^6.0.0",
-    "@libp2p/floodsub": "^8.0.9",
-    "@libp2p/interface-compliance-tests": "^4.1.1",
+    "@libp2p/floodsub": "8.0.10-346ff5a2",
+    "@libp2p/interface-compliance-tests": "4.1.2-346ff5a2",
     "@libp2p/interop": "^9.0.0",
-    "@libp2p/kad-dht": "^10.0.10",
-    "@libp2p/mdns": "^9.0.10",
-    "@libp2p/mplex": "^9.0.8",
-    "@libp2p/tcp": "^8.0.9",
-    "@libp2p/websockets": "^7.0.9",
+    "@libp2p/kad-dht": "10.0.11-346ff5a2",
+    "@libp2p/mdns": "9.0.11-346ff5a2",
+    "@libp2p/mplex": "9.0.9-346ff5a2",
+    "@libp2p/tcp": "8.0.10-346ff5a2",
+    "@libp2p/websockets": "7.0.10-346ff5a2",
     "@types/xsalsa20": "^1.1.0",
     "aegir": "^41.0.2",
     "execa": "^8.0.1",

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/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'
@@ -152,10 +152,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,5 +1,5 @@
-import { setMaxListeners } from 'events'
 import { AbortError, CodeError } from '@libp2p/interface/errors'
+import { setMaxListeners } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { type Multiaddr, type Resolver, resolvers } from '@multiformats/multiaddr'
@@ -96,10 +96,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')

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

@@ -72,6 +72,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

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 {

package/src/identify/identify.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 { peerIdFromKeys } from '@libp2p/peer-id'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
@@ -187,10 +187,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
 
       const signal = AbortSignal.timeout(this.timeout)
 
-      try {
-        // fails on node < 15.4
-        setMaxListeners?.(Infinity, signal)
-      } catch {}
+      setMaxListeners(Infinity, signal)
 
       try {
         stream = await connection.newStream([this.identifyPushProtocolStr], {
@@ -318,22 +315,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
       this.addressManager.addObservedAddr(cleanObservedAddr)
     }
 
-    const signedPeerRecord = await this.#consumeIdentifyMessage(connection.remotePeer, message)
-
-    const result: IdentifyResult = {
-      peerId: id,
-      protocolVersion: message.protocolVersion,
-      agentVersion: message.agentVersion,
-      publicKey: message.publicKey,
-      listenAddrs: message.listenAddrs.map(buf => multiaddr(buf)),
-      observedAddr: message.observedAddr == null ? undefined : multiaddr(message.observedAddr),
-      protocols: message.protocols,
-      signedPeerRecord
-    }
-
-    this.events.safeDispatchEvent('peer:identify', { detail: result })
-
-    return result
+    return this.#consumeIdentifyMessage(connection, message)
   }
 
   /**
@@ -345,10 +327,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
 
     const signal = AbortSignal.timeout(this.timeout)
 
-    try {
-      // fails on node < 15.4
-      setMaxListeners?.(Infinity, signal)
-    } catch {}
+    setMaxListeners(Infinity, signal)
 
     try {
       const publicKey = this.peerId.publicKey ?? new Uint8Array(0)
@@ -411,7 +390,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
       const message = await pb.read(options)
       await stream.close(options)
 
-      await this.#consumeIdentifyMessage(connection.remotePeer, message)
+      await this.#consumeIdentifyMessage(connection, message)
     } catch (err: any) {
       log.error('received invalid message', err)
       stream.abort(err)
@@ -421,8 +400,8 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
     log('handled push from %p', connection.remotePeer)
   }
 
-  async #consumeIdentifyMessage (remotePeer: PeerId, message: Identify): Promise<SignedPeerRecord | undefined> {
-    log('received identify from %p', remotePeer)
+  async #consumeIdentifyMessage (connection: Connection, message: Identify): Promise<IdentifyResult> {
+    log('received identify from %p', connection.remotePeer)
 
     if (message == null) {
       throw new Error('Message was null or undefined')
@@ -442,7 +421,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
 
     // if the peer record has been sent, prefer the addresses in the record as they are signed by the remote peer
     if (message.signedPeerRecord != null) {
-      log('received signedPeerRecord in push from %p', remotePeer)
+      log('received signedPeerRecord in push from %p', connection.remotePeer)
 
       let peerRecordEnvelope = message.signedPeerRecord
       const envelope = await RecordEnvelope.openAndCertify(peerRecordEnvelope, PeerRecord.DOMAIN)
@@ -454,7 +433,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
       }
 
       // Make sure remote peer is the one sending the record
-      if (!remotePeer.equals(peerRecord.peerId)) {
+      if (!connection.remotePeer.equals(peerRecord.peerId)) {
         throw new Error('signing key does not match remote PeerId')
       }
 
@@ -500,7 +479,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
         addresses: peerRecord.multiaddrs
       }
     } else {
-      log('%p did not send a signed peer record', remotePeer)
+      log('%p did not send a signed peer record', connection.remotePeer)
     }
 
     if (message.agentVersion != null) {
@@ -511,9 +490,23 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
       peer.metadata.set('ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
     }
 
-    await this.peerStore.patch(remotePeer, peer)
+    await this.peerStore.patch(connection.remotePeer, peer)
 
-    return output
+    const result: IdentifyResult = {
+      peerId: connection.remotePeer,
+      protocolVersion: message.protocolVersion,
+      agentVersion: message.agentVersion,
+      publicKey: message.publicKey,
+      listenAddrs: message.listenAddrs.map(buf => multiaddr(buf)),
+      observedAddr: message.observedAddr == null ? undefined : multiaddr(message.observedAddr),
+      protocols: message.protocols,
+      signedPeerRecord: output,
+      connection
+    }
+
+    this.events.safeDispatchEvent('peer:identify', { detail: result })
+
+    return result
   }
 }
 

package/src/libp2p.ts

@@ -1,8 +1,7 @@
-import { setMaxListeners } from 'events'
 import { unmarshalPublicKey } from '@libp2p/crypto/keys'
 import { type ContentRouting, contentRouting } from '@libp2p/interface/content-routing'
 import { CodeError } from '@libp2p/interface/errors'
-import { TypedEventEmitter, CustomEvent } from '@libp2p/interface/events'
+import { TypedEventEmitter, CustomEvent, setMaxListeners } from '@libp2p/interface/events'
 import { peerDiscovery } from '@libp2p/interface/peer-discovery'
 import { type PeerRouting, peerRouting } from '@libp2p/interface/peer-routing'
 import { DefaultKeyChain } from '@libp2p/keychain'
@@ -70,10 +69,8 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
       return internalResult || externalResult
     }
 
-    try {
-      // This emitter gets listened to a lot
-      setMaxListeners?.(Infinity, events)
-    } catch {}
+    // This emitter gets listened to a lot
+    setMaxListeners(Infinity, events)
 
     this.#started = false
     this.peerId = init.peerId

package/src/pnet/README.md

@@ -8,7 +8,6 @@ js-libp2p-pnet <!-- omit in toc -->
 ## Table of Contents <!-- omit in toc -->
 
 - [Usage](#usage)
-- [Examples](#examples)
 - [Private Shared Keys](#private-shared-keys)
 - [PSK Generation](#psk-generation)
     - [From a module using libp2p](#from-a-module-using-libp2p)
@@ -32,9 +31,6 @@ const node = await createLibp2p({
 })
 ```
 
-## Examples
-[Private Networks with IPFS](../../examples/pnet-ipfs)
-
 ## Private Shared Keys
 
 Private Shared Keys are expected to be in the following format:

package/src/registrar.ts

@@ -2,7 +2,7 @@ import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import merge from 'merge-options'
 import { codes } from './errors.js'
-import type { Libp2pEvents, PeerUpdate } from '@libp2p/interface'
+import type { IdentifyResult, Libp2pEvents, PeerUpdate } from '@libp2p/interface'
 import type { TypedEventTarget } from '@libp2p/interface/events'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { PeerStore } from '@libp2p/interface/peer-store'
@@ -37,11 +37,11 @@ export class DefaultRegistrar implements Registrar {
 
     this._onDisconnect = this._onDisconnect.bind(this)
     this._onPeerUpdate = this._onPeerUpdate.bind(this)
-    this._onConnect = this._onConnect.bind(this)
+    this._onPeerIdentify = this._onPeerIdentify.bind(this)
 
     this.components.events.addEventListener('peer:disconnect', this._onDisconnect)
-    this.components.events.addEventListener('peer:connect', this._onConnect)
     this.components.events.addEventListener('peer:update', this._onPeerUpdate)
+    this.components.events.addEventListener('peer:identify', this._onPeerIdentify)
   }
 
   getProtocols (): string[] {
@@ -183,52 +183,12 @@ export class DefaultRegistrar implements Registrar {
   }
 
   /**
-   * On peer connected if we already have their protocols. Usually used for reconnects
-   * as change:protocols event won't be emitted due to identical protocols.
-   */
-  _onConnect (evt: CustomEvent<PeerId>): void {
-    const remotePeer = evt.detail
-
-    void this.components.peerStore.get(remotePeer)
-      .then(peer => {
-        const connection = this.components.connectionManager.getConnections(peer.id)[0]
-
-        if (connection == null) {
-          log('peer %p connected but the connection manager did not have a connection', peer)
-          // peer disconnected while we were loading their details from the peer store
-          return
-        }
-
-        for (const protocol of peer.protocols) {
-          const topologies = this.topologies.get(protocol)
-
-          if (topologies == null) {
-            // no topologies are interested in this protocol
-            continue
-          }
-
-          for (const topology of topologies.values()) {
-            topology.onConnect?.(remotePeer, connection)
-          }
-        }
-      })
-      .catch(err => {
-        if (err.code === codes.ERR_NOT_FOUND) {
-          // peer has not completed identify so they are not in the peer store
-          return
-        }
-
-        log.error('could not inform topologies of connecting peer %p', remotePeer, err)
-      })
-  }
-
-  /**
-   * Check if a new peer support the multicodecs for this topology
+   * When a peer is updated, if they have removed supported protocols notify any
+   * topologies interested in the removed protocols.
    */
   _onPeerUpdate (evt: CustomEvent<PeerUpdate>): void {
     const { peer, previous } = evt.detail
     const removed = (previous?.protocols ?? []).filter(protocol => !peer.protocols.includes(protocol))
-    const added = peer.protocols.filter(protocol => !(previous?.protocols ?? []).includes(protocol))
 
     for (const protocol of removed) {
       const topologies = this.topologies.get(protocol)
@@ -242,8 +202,18 @@ export class DefaultRegistrar implements Registrar {
         topology.onDisconnect?.(peer.id)
       }
     }
+  }
 
-    for (const protocol of added) {
+  /**
+   * After identify has completed and we have received the list of supported
+   * protocols, notify any topologies interested in those protocols.
+   */
+  _onPeerIdentify (evt: CustomEvent<IdentifyResult>): void {
+    const protocols = evt.detail.protocols
+    const connection = evt.detail.connection
+    const peerId = evt.detail.peerId
+
+    for (const protocol of protocols) {
       const topologies = this.topologies.get(protocol)
 
       if (topologies == null) {
@@ -252,12 +222,11 @@ export class DefaultRegistrar implements Registrar {
       }
 
       for (const topology of topologies.values()) {
-        const connection = this.components.connectionManager.getConnections(peer.id)[0]
-
-        if (connection == null) {
+        if (connection.transient && topology.notifyOnTransient !== true) {
           continue
         }
-        topology.onConnect?.(peer.id, connection)
+
+        topology.onConnect?.(peerId, connection)
       }
     }
   }

package/src/upgrader.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 * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
@@ -170,10 +170,7 @@ export class DefaultUpgrader implements Upgrader {
 
     signal.addEventListener('abort', onAbort, { once: true })
 
-    try {
-      // fails on node < 15.4
-      setMaxListeners?.(Infinity, signal)
-    } catch { }
+    setMaxListeners(Infinity, signal)
 
     try {
       if ((await this.components.connectionGater.denyInboundConnection?.(maConn)) === true) {
@@ -444,10 +441,7 @@ export class DefaultUpgrader implements Upgrader {
 
             options.signal = AbortSignal.timeout(30000)
 
-            try {
-              // fails on node < 15.4
-              setMaxListeners?.(Infinity, options.signal)
-            } catch { }
+            setMaxListeners(Infinity, options.signal)
           }
 
           const { stream, protocol } = await mss.select(muxedStream, protocols, options)

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.46.15'
+export const version = '0.46.16-346ff5a2'
 export const name = 'libp2p'

package/dist/typedoc-urls.json

@@ -1,71 +0,0 @@
-{
-  "AutoNATComponents": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.autonat.AutoNATComponents.html",
-  "./autonat:AutoNATComponents": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.autonat.AutoNATComponents.html",
-  "AutoNATServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.autonat.AutoNATServiceInit.html",
-  "./autonat:AutoNATServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.autonat.AutoNATServiceInit.html",
-  "autoNATService": "https://libp2p.github.io/js-libp2p/functions/libp2p.autonat.autoNATService.html",
-  "./autonat:autoNATService": "https://libp2p.github.io/js-libp2p/functions/libp2p.autonat.autoNATService.html",
-  "CircuitRelayService": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.circuit_relay.CircuitRelayService.html",
-  "./circuit-relay:CircuitRelayService": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.circuit_relay.CircuitRelayService.html",
-  "CircuitRelayServiceEvents": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.circuit_relay.CircuitRelayServiceEvents.html",
-  "./circuit-relay:CircuitRelayServiceEvents": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.circuit_relay.CircuitRelayServiceEvents.html",
-  "RelayReservation": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.circuit_relay.RelayReservation.html",
-  "./circuit-relay:RelayReservation": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.circuit_relay.RelayReservation.html",
-  "circuitRelayServer": "https://libp2p.github.io/js-libp2p/functions/libp2p.circuit_relay.circuitRelayServer.html",
-  "circuitRelayTransport": "https://libp2p.github.io/js-libp2p/functions/libp2p.circuit_relay.circuitRelayTransport.html",
-  "FetchService": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.fetch.FetchService.html",
-  "./fetch:FetchService": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.fetch.FetchService.html",
-  "FetchServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.fetch.FetchServiceComponents.html",
-  "./fetch:FetchServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.fetch.FetchServiceComponents.html",
-  "FetchServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.fetch.FetchServiceInit.html",
-  "./fetch:FetchServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.fetch.FetchServiceInit.html",
-  "HandleMessageOptions": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.fetch.HandleMessageOptions.html",
-  "./fetch:HandleMessageOptions": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.fetch.HandleMessageOptions.html",
-  "LookupFunction": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.fetch.LookupFunction.html",
-  "./fetch:LookupFunction": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.fetch.LookupFunction.html",
-  "fetchService": "https://libp2p.github.io/js-libp2p/functions/libp2p.fetch.fetchService-1.html",
-  "./fetch:fetchService": "https://libp2p.github.io/js-libp2p/functions/libp2p.fetch.fetchService-1.html",
-  "IdentifyService": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.identify.IdentifyService.html",
-  "./identify:IdentifyService": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.identify.IdentifyService.html",
-  "IdentifyServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.identify.IdentifyServiceComponents.html",
-  "./identify:IdentifyServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.identify.IdentifyServiceComponents.html",
-  "IdentifyServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.identify.IdentifyServiceInit.html",
-  "./identify:IdentifyServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.identify.IdentifyServiceInit.html",
-  "Message": "https://libp2p.github.io/js-libp2p/variables/libp2p.identify.Message.html",
-  "./identify:Message": "https://libp2p.github.io/js-libp2p/variables/libp2p.identify.Message.html",
-  "multicodecs": "https://libp2p.github.io/js-libp2p/variables/libp2p.identify.multicodecs.html",
-  "./identify:multicodecs": "https://libp2p.github.io/js-libp2p/variables/libp2p.identify.multicodecs.html",
-  "identifyService": "https://libp2p.github.io/js-libp2p/functions/libp2p.identify.identifyService-1.html",
-  "./identify:identifyService": "https://libp2p.github.io/js-libp2p/functions/libp2p.identify.identifyService-1.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",
-  "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",
-  "plaintext": "https://libp2p.github.io/js-libp2p/functions/libp2p.insecure.plaintext.html",
-  "./insecure:plaintext": "https://libp2p.github.io/js-libp2p/functions/libp2p.insecure.plaintext.html",
-  "PingService": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.ping.PingService.html",
-  "./ping:PingService": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.ping.PingService.html",
-  "PingServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.ping.PingServiceComponents.html",
-  "./ping:PingServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.ping.PingServiceComponents.html",
-  "PingServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.ping.PingServiceInit.html",
-  "./ping:PingServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.ping.PingServiceInit.html",
-  "pingService": "https://libp2p.github.io/js-libp2p/functions/libp2p.ping.pingService-1.html",
-  "./ping:pingService": "https://libp2p.github.io/js-libp2p/functions/libp2p.ping.pingService-1.html",
-  "ProtectorInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.pnet.ProtectorInit.html",
-  "./pnet:ProtectorInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.pnet.ProtectorInit.html",
-  "generateKey": "https://libp2p.github.io/js-libp2p/functions/libp2p.pnet.generateKey.html",
-  "preSharedKey": "https://libp2p.github.io/js-libp2p/functions/libp2p.pnet.preSharedKey.html",
-  "./pnet:preSharedKey": "https://libp2p.github.io/js-libp2p/functions/libp2p.pnet.preSharedKey.html",
-  "PMPOptions": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.upnp_nat.PMPOptions.html",
-  "./upnp-nat:PMPOptions": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.upnp_nat.PMPOptions.html",
-  "UPnPNATComponents": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.upnp_nat.UPnPNATComponents.html",
-  "./upnp-nat:UPnPNATComponents": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.upnp_nat.UPnPNATComponents.html",
-  "UPnPNATInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.upnp_nat.UPnPNATInit.html",
-  "./upnp-nat:UPnPNATInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.upnp_nat.UPnPNATInit.html",
-  "uPnPNATService": "https://libp2p.github.io/js-libp2p/functions/libp2p.upnp_nat.uPnPNATService.html",
-  "./upnp-nat:uPnPNATService": "https://libp2p.github.io/js-libp2p/functions/libp2p.upnp_nat.uPnPNATService.html"
-}