libp2p 0.45.4 → 0.45.5-775f8928

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

@@ -1,7 +1,7 @@
 import { logger } from '@libp2p/logger'
 import { PeerMap, PeerSet } from '@libp2p/peer-collections'
-import PQueue from 'p-queue'
-import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_INTERVAL, AUTO_DIAL_PRIORITY, MIN_CONNECTIONS } from './constants.js'
+import { PeerJobQueue } from '../utils/peer-job-queue.js'
+import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_INTERVAL, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PRIORITY, MIN_CONNECTIONS } from './constants.js'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 import type { PeerStore } from '@libp2p/interface-peer-store'
@@ -12,6 +12,7 @@ const log = logger('libp2p:connection-manager:auto-dial')
 
 interface AutoDialInit {
   minConnections?: number
+  maxQueueLength?: number
   autoDialConcurrency?: number
   autoDialPriority?: number
   autoDialInterval?: number
@@ -25,6 +26,7 @@ interface AutoDialComponents {
 
 const defaultOptions = {
   minConnections: MIN_CONNECTIONS,
+  maxQueueLength: AUTO_DIAL_MAX_QUEUE_LENGTH,
   autoDialConcurrency: AUTO_DIAL_CONCURRENCY,
   autoDialPriority: AUTO_DIAL_PRIORITY,
   autoDialInterval: AUTO_DIAL_INTERVAL
@@ -33,12 +35,14 @@ const defaultOptions = {
 export class AutoDial implements Startable {
   private readonly connectionManager: ConnectionManager
   private readonly peerStore: PeerStore
-  private readonly queue: PQueue
+  private readonly queue: PeerJobQueue
   private readonly minConnections: number
   private readonly autoDialPriority: number
   private readonly autoDialIntervalMs: number
+  private readonly autoDialMaxQueueLength: number
   private autoDialInterval?: ReturnType<typeof setInterval>
   private started: boolean
+  private running: boolean
 
   /**
    * Proactively tries to connect to known peers stored in the PeerStore.
@@ -51,8 +55,10 @@ export class AutoDial implements Startable {
     this.minConnections = init.minConnections ?? defaultOptions.minConnections
     this.autoDialPriority = init.autoDialPriority ?? defaultOptions.autoDialPriority
     this.autoDialIntervalMs = init.autoDialInterval ?? defaultOptions.autoDialInterval
+    this.autoDialMaxQueueLength = init.maxQueueLength ?? defaultOptions.maxQueueLength
     this.started = false
-    this.queue = new PQueue({
+    this.running = false
+    this.queue = new PeerJobQueue({
       concurrency: init.autoDialConcurrency ?? defaultOptions.autoDialConcurrency
     })
     this.queue.addListener('error', (err) => {
@@ -73,7 +79,7 @@ export class AutoDial implements Startable {
   }
 
   start (): void {
-    this.autoDialInterval = setInterval(() => {
+    this.autoDialInterval = setTimeout(() => {
       this.autoDial()
         .catch(err => {
           log.error('error while autodialing', err)
@@ -92,8 +98,9 @@ export class AutoDial implements Startable {
   stop (): void {
     // clear the queue
     this.queue.clear()
-    clearInterval(this.autoDialInterval)
+    clearTimeout(this.autoDialInterval)
     this.started = false
+    this.running = false
   }
 
   async autoDial (): Promise<void> {
@@ -103,12 +110,6 @@ export class AutoDial implements Startable {
 
     const connections = this.connectionManager.getConnectionsMap()
     const numConnections = connections.size
-    const dialQueue = new PeerSet(
-      // @ts-expect-error boolean filter removes falsy peer IDs
-      this.connectionManager.getDialQueue()
-        .map(queue => queue.peerId)
-        .filter(Boolean)
-    )
 
     // Already has enough connections
     if (numConnections >= this.minConnections) {
@@ -116,34 +117,64 @@ export class AutoDial implements Startable {
       return
     }
 
-    log('not enough connections %d/%d - will dial peers to increase the number of connections', numConnections, this.minConnections)
+    if (this.queue.size > this.autoDialMaxQueueLength) {
+      log('not enough connections %d/%d but auto dial queue is full', numConnections, this.minConnections)
+      return
+    }
 
-    // Sort peers on whether we know protocols or public keys for them
-    const peers = await this.peerStore.all()
+    if (this.running) {
+      log('not enough connections %d/%d - but skipping autodial as it is already running', numConnections, this.minConnections)
+      return
+    }
 
-    // Remove some peers
-    const filteredPeers = peers.filter((peer) => {
-      // Remove peers without addresses
-      if (peer.addresses.length === 0) {
-        return false
-      }
+    this.running = true
 
-      // remove peers we are already connected to
-      if (connections.has(peer.id)) {
-        return false
-      }
+    log('not enough connections %d/%d - will dial peers to increase the number of connections', numConnections, this.minConnections)
 
-      // remove peers we are already dialling
-      if (dialQueue.has(peer.id)) {
-        return false
-      }
+    const dialQueue = new PeerSet(
+      // @ts-expect-error boolean filter removes falsy peer IDs
+      this.connectionManager.getDialQueue()
+        .map(queue => queue.peerId)
+        .filter(Boolean)
+    )
 
-      return true
+    // Sort peers on whether we know protocols or public keys for them
+    const peers = await this.peerStore.all({
+      filters: [
+        // Remove some peers
+        (peer) => {
+          // Remove peers without addresses
+          if (peer.addresses.length === 0) {
+            log.trace('not autodialing %p because they have no addresses')
+            return false
+          }
+
+          // remove peers we are already connected to
+          if (connections.has(peer.id)) {
+            log.trace('not autodialing %p because they are already connected')
+            return false
+          }
+
+          // remove peers we are already dialling
+          if (dialQueue.has(peer.id)) {
+            log.trace('not autodialing %p because they are already being dialed')
+            return false
+          }
+
+          // remove peers already in the autodial queue
+          if (this.queue.hasJob(peer.id)) {
+            log.trace('not autodialing %p because they are already being autodialed')
+            return false
+          }
+
+          return true
+        }
+      ]
     })
 
     // shuffle the peers - this is so peers with the same tag values will be
     // dialled in a different order each time
-    const shuffledPeers = filteredPeers.sort(() => Math.random() > 0.5 ? 1 : -1)
+    const shuffledPeers = peers.sort(() => Math.random() > 0.5 ? 1 : -1)
 
     // Sort shuffled peers by tag value
     const peerValues = new PeerMap<number>()
@@ -192,9 +223,22 @@ export class AutoDial implements Startable {
           // @ts-expect-error needs adding to the ConnectionManager interface
           priority: this.autoDialPriority
         })
+      }, {
+        peerId: peer.id
       }).catch(err => {
         log.error('could not connect to peerStore stored peer', err)
       })
     }
+
+    this.running = false
+
+    if (this.started) {
+      this.autoDialInterval = setTimeout(() => {
+        this.autoDial()
+          .catch(err => {
+            log.error('error while autodialing', err)
+          })
+      }, this.autoDialIntervalMs)
+    }
   }
 }

package/src/connection-manager/constants.ts

@@ -49,6 +49,11 @@ export const AUTO_DIAL_CONCURRENCY = 25
  */
 export const AUTO_DIAL_PRIORITY = 0
 
+/**
+ * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#autoDialMaxQueueLength
+ */
+export const AUTO_DIAL_MAX_QUEUE_LENGTH = 100
+
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#inboundConnectionThreshold
  */

package/src/connection-manager/index.ts

@@ -10,7 +10,7 @@ import { codes } from '../errors.js'
 import { getPeerAddress } from '../get-peer.js'
 import { AutoDial } from './auto-dial.js'
 import { ConnectionPruner } from './connection-pruner.js'
-import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_PRIORITY, DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL, MIN_CONNECTIONS } from './constants.js'
+import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PRIORITY, DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL, MIN_CONNECTIONS } from './constants.js'
 import { DialQueue } from './dial-queue.js'
 import type { Connection, MultiaddrConnection } from '@libp2p/interface-connection'
 import type { ConnectionGater } from '@libp2p/interface-connection-gater'
@@ -18,7 +18,7 @@ import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { PendingDial, AddressSorter, Libp2pEvents } from '@libp2p/interface-libp2p'
 import type { Metrics } from '@libp2p/interface-metrics'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { Peer, PeerStore } from '@libp2p/interface-peer-store'
 import type { TransportManager } from '@libp2p/interface-transport'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { EventEmitter } from '@libp2p/interfaces/events'
@@ -61,6 +61,12 @@ export interface ConnectionManagerInit {
    */
   autoDialPriority?: number
 
+  /**
+   * Limit the maximum number of peers to dial when trying to keep the number of
+   * open connections above `minConnections`. (default: 100)
+   */
+  autoDialMaxQueueLength?: number
+
   /**
    * Sort the known addresses of a peer before trying to dial, By default public
    * addresses will be dialled before private (e.g. loopback or LAN) addresses.
@@ -136,7 +142,8 @@ const defaultOptions = {
   inboundConnectionThreshold: INBOUND_CONNECTION_THRESHOLD,
   maxIncomingPendingConnections: MAX_INCOMING_PENDING_CONNECTIONS,
   autoDialConcurrency: AUTO_DIAL_CONCURRENCY,
-  autoDialPriority: AUTO_DIAL_PRIORITY
+  autoDialPriority: AUTO_DIAL_PRIORITY,
+  autoDialMaxQueueLength: AUTO_DIAL_MAX_QUEUE_LENGTH
 }
 
 export interface DefaultConnectionManagerComponents {
@@ -217,7 +224,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     }, {
       minConnections,
       autoDialConcurrency: init.autoDialConcurrency ?? defaultOptions.autoDialConcurrency,
-      autoDialPriority: init.autoDialPriority ?? defaultOptions.autoDialPriority
+      autoDialPriority: init.autoDialPriority ?? defaultOptions.autoDialPriority,
+      maxQueueLength: init.autoDialMaxQueueLength ?? defaultOptions.autoDialMaxQueueLength
     })
 
     // controls what happens when we have too many connections
@@ -344,17 +352,15 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     // re-connect to any peers with the KEEP_ALIVE tag
     void Promise.resolve()
       .then(async () => {
-        const keepAlivePeers: PeerId[] = []
-
-        for (const peer of await this.peerStore.all()) {
-          if (peer.tags.has(KEEP_ALIVE)) {
-            keepAlivePeers.push(peer.id)
-          }
-        }
+        const keepAlivePeers: Peer[] = await this.peerStore.all({
+          filters: [(peer) => {
+            return peer.tags.has(KEEP_ALIVE)
+          }]
+        })
 
         await Promise.all(
           keepAlivePeers.map(async peer => {
-            await this.openConnection(peer)
+            await this.openConnection(peer.id)
               .catch(err => {
                 log.error(err)
               })

package/src/identify/identify.ts

@@ -429,79 +429,98 @@ export class DefaultIdentifyService implements Startable {
   }
 
   async #consumeIdentifyMessage (remotePeer: PeerId, message: Identify): Promise<SignedPeerRecord | undefined> {
+    log('received identify from %p', remotePeer)
+
     if (message == null) {
       throw new Error('Message was null or undefined')
     }
 
-    log('received identify from %p', remotePeer)
-
-    if (message.signedPeerRecord == null) {
-      return
+    const peer = {
+      addresses: message.listenAddrs.map(buf => ({
+        isCertified: false,
+        multiaddr: multiaddr(buf)
+      })),
+      protocols: message.protocols,
+      metadata: new Map(),
+      peerRecordEnvelope: message.signedPeerRecord
     }
 
-    let peerRecordEnvelope = message.signedPeerRecord
-    const envelope = await RecordEnvelope.openAndCertify(peerRecordEnvelope, PeerRecord.DOMAIN)
-    let peerRecord = PeerRecord.createFromProtobuf(envelope.payload)
+    let output: SignedPeerRecord | undefined
 
-    // Verify peerId
-    if (!peerRecord.peerId.equals(envelope.peerId)) {
-      throw new Error('signing key does not match PeerId in the PeerRecord')
-    }
+    // 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)
 
-    // Make sure remote peer is the one sending the record
-    if (!remotePeer.equals(peerRecord.peerId)) {
-      throw new Error('signing key does not match remote PeerId')
-    }
+      let peerRecordEnvelope = message.signedPeerRecord
+      const envelope = await RecordEnvelope.openAndCertify(peerRecordEnvelope, PeerRecord.DOMAIN)
+      let peerRecord = PeerRecord.createFromProtobuf(envelope.payload)
 
-    let peer: Peer | undefined
+      // Verify peerId
+      if (!peerRecord.peerId.equals(envelope.peerId)) {
+        throw new Error('signing key does not match PeerId in the PeerRecord')
+      }
 
-    try {
-      peer = await this.peerStore.get(peerRecord.peerId)
-    } catch (err: any) {
-      if (err.code !== 'ERR_NOT_FOUND') {
-        throw err
+      // Make sure remote peer is the one sending the record
+      if (!remotePeer.equals(peerRecord.peerId)) {
+        throw new Error('signing key does not match remote PeerId')
+      }
+
+      let existingPeer: Peer | undefined
+
+      try {
+        existingPeer = await this.peerStore.get(peerRecord.peerId)
+      } catch (err: any) {
+        if (err.code !== 'ERR_NOT_FOUND') {
+          throw err
+        }
       }
-    }
 
-    log('received signedPeerRecord in push from %p', remotePeer)
-    const metadata = peer?.metadata ?? new Map()
+      if (existingPeer != null) {
+        // don't lose any existing metadata
+        peer.metadata = existingPeer.metadata
 
-    if (peer?.peerRecordEnvelope != null) {
-      const storedEnvelope = await RecordEnvelope.createFromProtobuf(peer.peerRecordEnvelope)
-      const storedRecord = PeerRecord.createFromProtobuf(storedEnvelope.payload)
+        // if we have previously received a signed record for this peer, compare it to the incoming one
+        if (existingPeer.peerRecordEnvelope != null) {
+          const storedEnvelope = await RecordEnvelope.createFromProtobuf(existingPeer.peerRecordEnvelope)
+          const storedRecord = PeerRecord.createFromProtobuf(storedEnvelope.payload)
 
-      // ensure seq is greater than, or equal to, the last received
-      if (storedRecord.seqNumber >= peerRecord.seqNumber) {
-        log('sequence number was lower or equal to existing sequence number - stored: %d received: %d', storedRecord.seqNumber, peerRecord.seqNumber)
-        peerRecord = storedRecord
-        peerRecordEnvelope = peer.peerRecordEnvelope
+          // ensure seq is greater than, or equal to, the last received
+          if (storedRecord.seqNumber >= peerRecord.seqNumber) {
+            log('sequence number was lower or equal to existing sequence number - stored: %d received: %d', storedRecord.seqNumber, peerRecord.seqNumber)
+            peerRecord = storedRecord
+            peerRecordEnvelope = existingPeer.peerRecordEnvelope
+          }
+        }
       }
+
+      // store the signed record for next time
+      peer.peerRecordEnvelope = peerRecordEnvelope
+
+      // override the stored addresses with the signed multiaddrs
+      peer.addresses = peerRecord.multiaddrs.map(multiaddr => ({
+        isCertified: true,
+        multiaddr
+      }))
+
+      output = {
+        seq: peerRecord.seqNumber,
+        addresses: peerRecord.multiaddrs
+      }
+    } else {
+      log('%p did not send a signed peer record', remotePeer)
     }
 
     if (message.agentVersion != null) {
-      metadata.set('AgentVersion', uint8ArrayFromString(message.agentVersion))
+      peer.metadata.set('AgentVersion', uint8ArrayFromString(message.agentVersion))
     }
 
     if (message.protocolVersion != null) {
-      metadata.set('ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
+      peer.metadata.set('ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
     }
 
-    await this.peerStore.patch(peerRecord.peerId, {
-      peerRecordEnvelope,
-      protocols: message.protocols,
-      addresses: peerRecord.multiaddrs.map(multiaddr => ({
-        isCertified: true,
-        multiaddr
-      })),
-      metadata
-    })
-
-    log('consumed signedPeerRecord sent in push from %p', remotePeer)
+    await this.peerStore.patch(remotePeer, peer)
 
-    return {
-      seq: peerRecord.seqNumber,
-      addresses: peerRecord.multiaddrs
-    }
+    return output
   }
 }
 

package/src/upnp-nat/index.ts

@@ -142,7 +142,7 @@ class UPnPNAT implements Startable {
         continue
       }
 
-      const client = await this._getClient()
+      const client = this._getClient()
       const publicIp = this.externalAddress ?? await client.externalIp()
       const isPrivate = isPrivateIp(publicIp)
 
@@ -173,12 +173,12 @@ class UPnPNAT implements Startable {
     }
   }
 
-  async _getClient (): Promise<NatAPI> {
+  _getClient (): NatAPI {
     if (this.client != null) {
       return this.client
     }
 
-    this.client = await upnpNat({
+    this.client = upnpNat({
       description: this.description,
       ttl: this.ttl,
       keepAlive: this.keepAlive,

package/src/utils/peer-job-queue.ts

@@ -0,0 +1,119 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import { CodeError } from '@libp2p/interfaces/errors'
+import PQueue from 'p-queue'
+import { codes } from '../errors.js'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { QueueAddOptions, Options, Queue } from 'p-queue'
+
+// Port of lower_bound from https://en.cppreference.com/w/cpp/algorithm/lower_bound
+// Used to compute insertion index to keep queue sorted after insertion
+function lowerBound<T> (array: readonly T[], value: T, comparator: (a: T, b: T) => number): number {
+  let first = 0
+  let count = array.length
+
+  while (count > 0) {
+    const step = Math.trunc(count / 2)
+    let it = first + step
+
+    if (comparator(array[it]!, value) <= 0) {
+      first = ++it
+      count -= step + 1
+    } else {
+      count = step
+    }
+  }
+
+  return first
+}
+
+interface RunFunction { (): Promise<unknown> }
+
+export interface PeerPriorityQueueOptions extends QueueAddOptions {
+  peerId: PeerId
+}
+
+interface PeerJob {
+  priority: number
+  peerId: PeerId
+  run: RunFunction
+}
+
+/**
+ * Port of https://github.com/sindresorhus/p-queue/blob/main/source/priority-queue.ts
+ * that adds support for filtering jobs by peer id
+ */
+class PeerPriorityQueue implements Queue<RunFunction, PeerPriorityQueueOptions> {
+  readonly #queue: PeerJob[] = []
+
+  enqueue (run: RunFunction, options?: Partial<PeerPriorityQueueOptions>): void {
+    const peerId = options?.peerId
+    const priority = options?.priority ?? 0
+
+    if (peerId == null) {
+      throw new CodeError('missing peer id', codes.ERR_INVALID_PARAMETERS)
+    }
+
+    const element: PeerJob = {
+      priority,
+      peerId,
+      run
+    }
+
+    if (this.size > 0 && this.#queue[this.size - 1]!.priority >= priority) {
+      this.#queue.push(element)
+      return
+    }
+
+    const index = lowerBound(
+      this.#queue, element,
+      (a: Readonly<PeerPriorityQueueOptions>, b: Readonly<PeerPriorityQueueOptions>) => b.priority! - a.priority!
+    )
+    this.#queue.splice(index, 0, element)
+  }
+
+  dequeue (): RunFunction | undefined {
+    const item = this.#queue.shift()
+    return item?.run
+  }
+
+  filter (options: Readonly<Partial<PeerPriorityQueueOptions>>): RunFunction[] {
+    if (options.peerId != null) {
+      const peerId = options.peerId
+
+      return this.#queue.filter(
+        (element: Readonly<PeerPriorityQueueOptions>) => peerId.equals(element.peerId)
+      ).map((element: Readonly<{ run: RunFunction }>) => element.run)
+    }
+
+    return this.#queue.filter(
+      (element: Readonly<PeerPriorityQueueOptions>) => element.priority === options.priority
+    ).map((element: Readonly<{ run: RunFunction }>) => element.run)
+  }
+
+  get size (): number {
+    return this.#queue.length
+  }
+}
+
+/**
+ * Extends PQueue to add support for querying queued jobs by peer id
+ */
+export class PeerJobQueue extends PQueue<PeerPriorityQueue, PeerPriorityQueueOptions> {
+  constructor (options: Options<PeerPriorityQueue, PeerPriorityQueueOptions> = {}) {
+    super({
+      ...options,
+      queueClass: PeerPriorityQueue
+    })
+  }
+
+  /**
+   * Returns true if this queue has a job for the passed peer id that has not yet
+   * started to run
+   */
+  hasJob (peerId: PeerId): boolean {
+    return this.sizeBy({
+      peerId
+    }) > 0
+  }
+}

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.45.4'
+export const version = '0.45.5-775f8928'
 export const name = 'libp2p'

package/dist/typedoc-urls.json

@@ -1,58 +0,0 @@
-{
-  "AutoNATComponents": "https://libp2p.github.io/js-libp2p/interfaces/autonat.AutoNATComponents.html",
-  "AutoNATServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/autonat.AutoNATServiceInit.html",
-  "autoNATService": "https://libp2p.github.io/js-libp2p/functions/autonat.autoNATService.html",
-  "codec": "https://libp2p.github.io/js-libp2p/functions/circuit_relay._internal_.Limit.codec.html",
-  "decode": "https://libp2p.github.io/js-libp2p/functions/circuit_relay._internal_.Limit.decode.html",
-  "encode": "https://libp2p.github.io/js-libp2p/functions/circuit_relay._internal_.Limit.encode.html",
-  "AdvertServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay._internal_.AdvertServiceComponents.html",
-  "AdvertServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay._internal_.AdvertServiceInit.html",
-  "CircuitRelayServerComponents": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay._internal_.CircuitRelayServerComponents.html",
-  "CircuitRelayServerInit": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay._internal_.CircuitRelayServerInit.html",
-  "CircuitRelayTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay._internal_.CircuitRelayTransportComponents.html",
-  "CircuitRelayTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay._internal_.CircuitRelayTransportInit.html",
-  "Limit": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay._internal_.Limit-1.html",
-  "RelayDiscoveryComponents": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay._internal_.RelayDiscoveryComponents.html",
-  "RelayStoreInit": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay._internal_.RelayStoreInit.html",
-  "ReservationStoreInit": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay._internal_.ReservationStoreInit.html",
-  "CircuitRelayService": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay.CircuitRelayService.html",
-  "CircuitRelayServiceEvents": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay.CircuitRelayServiceEvents.html",
-  "RelayReservation": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay.RelayReservation.html",
-  "circuitRelayServer": "https://libp2p.github.io/js-libp2p/functions/circuit_relay.circuitRelayServer.html",
-  "circuitRelayTransport": "https://libp2p.github.io/js-libp2p/functions/circuit_relay.circuitRelayTransport.html",
-  "FetchService": "https://libp2p.github.io/js-libp2p/interfaces/fetch.FetchService.html",
-  "FetchServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/fetch.FetchServiceComponents.html",
-  "FetchServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/fetch.FetchServiceInit.html",
-  "HandleMessageOptions": "https://libp2p.github.io/js-libp2p/interfaces/fetch.HandleMessageOptions.html",
-  "LookupFunction": "https://libp2p.github.io/js-libp2p/interfaces/fetch.LookupFunction.html",
-  "fetchService": "https://libp2p.github.io/js-libp2p/functions/fetch.fetchService-1.html",
-  "DefaultIdentifyService": "https://libp2p.github.io/js-libp2p/classes/identify._internal_.DefaultIdentifyService.html",
-  "Identify": "https://libp2p.github.io/js-libp2p/interfaces/identify._internal_.Identify-1.html",
-  "IdentifyServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/identify.IdentifyServiceComponents.html",
-  "IdentifyServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/identify.IdentifyServiceInit.html",
-  "Message": "https://libp2p.github.io/js-libp2p/variables/identify.Message.html",
-  "multicodecs": "https://libp2p.github.io/js-libp2p/variables/identify.multicodecs.html",
-  "identifyService": "https://libp2p.github.io/js-libp2p/functions/identify.identifyService.html",
-  "AddressFilter": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.AddressFilter.html",
-  "AddressManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.AddressManagerInit.html",
-  "Components": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.Components.html",
-  "ConnectionManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerInit.html",
-  "TransportManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.TransportManagerInit.html",
-  "Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/index.Libp2pInit.html",
-  "Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/index.Libp2pOptions.html",
-  "ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/index.ServiceFactoryMap.html",
-  "createLibp2p": "https://libp2p.github.io/js-libp2p/functions/index.createLibp2p.html",
-  "plaintext": "https://libp2p.github.io/js-libp2p/functions/insecure.plaintext.html",
-  "PingService": "https://libp2p.github.io/js-libp2p/interfaces/ping.PingService.html",
-  "PingServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/ping.PingServiceComponents.html",
-  "PingServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/ping.PingServiceInit.html",
-  "pingService": "https://libp2p.github.io/js-libp2p/functions/ping.pingService-1.html",
-  "ProtectorInit": "https://libp2p.github.io/js-libp2p/interfaces/pnet.ProtectorInit.html",
-  "generateKey": "https://libp2p.github.io/js-libp2p/functions/pnet.generateKey.html",
-  "preSharedKey": "https://libp2p.github.io/js-libp2p/functions/pnet.preSharedKey.html",
-  "UPnPNAT": "https://libp2p.github.io/js-libp2p/classes/upnp_nat._internal_.UPnPNAT.html",
-  "PMPOptions": "https://libp2p.github.io/js-libp2p/interfaces/upnp_nat.PMPOptions.html",
-  "UPnPNATComponents": "https://libp2p.github.io/js-libp2p/interfaces/upnp_nat.UPnPNATComponents.html",
-  "UPnPNATInit": "https://libp2p.github.io/js-libp2p/interfaces/upnp_nat.UPnPNATInit.html",
-  "uPnPNATService": "https://libp2p.github.io/js-libp2p/functions/upnp_nat.uPnPNATService.html"
-}