@libp2p/webrtc 5.2.8 → 5.2.9-4c64bd06d

package/src/private-to-public/listener.ts

@@ -1,49 +1,46 @@
-import { networkInterfaces } from 'node:os'
-import { isIPv4, isIPv6 } from '@chainsafe/is-ip'
-import { InvalidPeerIdError, TypedEventEmitter } from '@libp2p/interface'
-import { multiaddr, protocols, fromStringTuples } from '@multiformats/multiaddr'
-import { IP4, WebRTCDirect } from '@multiformats/multiaddr-matcher'
-import { Crypto } from '@peculiar/webcrypto'
+import { isIPv4 } from '@chainsafe/is-ip'
+import { InvalidParametersError, TypedEventEmitter } from '@libp2p/interface'
+import { getThinWaistAddresses } from '@libp2p/utils/get-thin-waist-addresses'
+import { multiaddr, fromStringTuples } from '@multiformats/multiaddr'
+import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import getPort from 'get-port'
 import pWaitFor from 'p-wait-for'
 import { CODEC_CERTHASH, CODEC_WEBRTC_DIRECT } from '../constants.js'
 import { connect } from './utils/connect.js'
-import { generateTransportCertificate } from './utils/generate-certificates.js'
 import { createDialerRTCPeerConnection } from './utils/get-rtcpeerconnection.js'
 import { stunListener } from './utils/stun-listener.js'
 import type { DataChannelOptions, TransportCertificate } from '../index.js'
+import type { WebRTCDirectTransportCertificateEvents } from './transport.js'
 import type { DirectRTCPeerConnection } from './utils/get-rtcpeerconnection.js'
 import type { StunServer } from './utils/stun-listener.js'
-import type { PeerId, ListenerEvents, Listener, Upgrader, ComponentLogger, Logger, CounterGroup, Metrics, PrivateKey } from '@libp2p/interface'
+import type { PeerId, ListenerEvents, Listener, Upgrader, ComponentLogger, Logger, CounterGroup, Metrics, PrivateKey, TypedEventTarget } from '@libp2p/interface'
+import type { Keychain } from '@libp2p/keychain'
 import type { Multiaddr } from '@multiformats/multiaddr'
-
-const crypto = new Crypto()
+import type { Datastore } from 'interface-datastore'
 
 export interface WebRTCDirectListenerComponents {
   peerId: PeerId
   privateKey: PrivateKey
   logger: ComponentLogger
   upgrader: Upgrader
+  keychain?: Keychain
+  datastore: Datastore
   metrics?: Metrics
 }
 
 export interface WebRTCDirectListenerInit {
   upgrader: Upgrader
-  certificates?: TransportCertificate[]
+  certificate: TransportCertificate
   maxInboundStreams?: number
   dataChannel?: DataChannelOptions
   rtcConfiguration?: RTCConfiguration | (() => RTCConfiguration | Promise<RTCConfiguration>)
-  useLibjuice?: boolean
+  emitter: TypedEventTarget<WebRTCDirectTransportCertificateEvents>
 }
 
 export interface WebRTCListenerMetrics {
   listenerEvents: CounterGroup
 }
 
-const UDP_PROTOCOL = protocols('udp')
-const IP4_PROTOCOL = protocols('ip4')
-const IP6_PROTOCOL = protocols('ip6')
-
 interface UDPMuxServer {
   server: Promise<StunServer>
   isIPv4: boolean
@@ -56,8 +53,9 @@ interface UDPMuxServer {
 let UDP_MUX_LISTENERS: UDPMuxServer[] = []
 
 export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> implements Listener {
-  private readonly multiaddrs: Multiaddr[]
-  private certificate?: TransportCertificate
+  private listeningMultiaddr?: Multiaddr
+  private certificate: TransportCertificate
+  private stunServer?: StunServer
   private readonly connections: Map<string, DirectRTCPeerConnection>
   private readonly log: Logger
   private readonly init: WebRTCDirectListenerInit
@@ -70,11 +68,10 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
 
     this.init = init
     this.components = components
-    this.multiaddrs = []
     this.connections = new Map()
     this.log = components.logger.forComponent('libp2p:webrtc-direct:listener')
-    this.certificate = init.certificates?.[0]
     this.shutdownController = new AbortController()
+    this.certificate = init.certificate
 
     if (components.metrics != null) {
       this.metrics = {
@@ -84,95 +81,64 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
         })
       }
     }
+
+    // inform the transport manager our addresses have changed
+    init.emitter.addEventListener('certificate:renew', evt => {
+      this.certificate = evt.detail
+      this.safeDispatchEvent('listening')
+    })
   }
 
   async listen (ma: Multiaddr): Promise<void> {
-    const parts = ma.stringTuples()
-    const ipVersion = IP4.matches(ma) ? 4 : 6
-    const host = parts
-      .filter(([code]) => code === IP4_PROTOCOL.code)
-      .pop()?.[1] ?? parts
-      .filter(([code]) => code === IP6_PROTOCOL.code)
-      .pop()?.[1]
-
-    if (host == null) {
-      throw new Error('IP4/6 host must be specified in webrtc-direct multiaddr')
-    }
-    const port = parseInt(parts
-      .filter(([code, value]) => code === UDP_PROTOCOL.code)
-      .pop()?.[1] ?? '')
+    const { host, port, family } = ma.toOptions()
 
-    if (isNaN(port)) {
-      throw new Error('UDP port must be specified in webrtc-direct multiaddr')
-    }
+    let udpMuxServer: UDPMuxServer | undefined
 
-    // have to do this before any async work happens so starting two listeners
-    // for the same port concurrently (e.g. ipv4/ipv6 both port 0) results in a
-    // single mux listener. This is necessary because libjuice binds to all
-    // interfaces for a given port so we we need to key on just the port number
-    // not the host + the port number
-    let existingServer = UDP_MUX_LISTENERS.find(s => s.port === port)
-
-    // if the server has not been started yet, or the port is a wildcard port
-    // and there is already a wildcard port for this address family, start a new
-    // UDP mux server
-    const wildcardPorts = port === 0 && existingServer?.port === 0
-    const sameAddressFamily = (existingServer?.isIPv4 === true && isIPv4(host)) || (existingServer?.isIPv6 === true && isIPv6(host))
-    let createdMuxServer = false
-
-    if (existingServer == null || (wildcardPorts && sameAddressFamily)) {
-      this.log('starting UDP mux server on %s:%p', host, port)
-      existingServer = this.startUDPMuxServer(host, port)
-      UDP_MUX_LISTENERS.push(existingServer)
-      createdMuxServer = true
-    }
+    if (port !== 0) {
+      // libjuice binds to all interfaces (IPv4/IPv6) for a given port so if we
+      // want to listen on a specific port, and there's already a mux listener
+      // for that port for the other family started by this node, we should
+      // reuse it
+      udpMuxServer = UDP_MUX_LISTENERS.find(s => s.port === port)
 
-    if (!existingServer.peerId.equals(this.components.peerId)) {
-      // this would have to be another in-process peer so we are likely in a
-      // testing environment
-      throw new InvalidPeerIdError(`Another peer is already performing UDP mux on ${host}:${existingServer.port}`)
-    }
+      // make sure the port is free for the given family
+      if (udpMuxServer != null && ((udpMuxServer.isIPv4 && family === 4) || (udpMuxServer.isIPv6 && family === 6))) {
+        throw new InvalidParametersError(`There is already a listener for ${host}:${port}`)
+      }
 
-    const server = await existingServer.server
-    const address = server.address()
+      // check that we own the mux server
+      if (udpMuxServer != null && !udpMuxServer.peerId.equals(this.components.peerId)) {
+        throw new InvalidParametersError(`Another peer is already performing UDP mux on ${host}:${port}`)
+      }
+    }
 
-    if (!createdMuxServer) {
-      this.log('reused existing UDP mux server on %s:%p', host, address.port)
+    // start the mux server if we don't have one already
+    if (udpMuxServer == null) {
+      this.log('starting UDP mux server on %s:%p', host, port)
+      udpMuxServer = this.startUDPMuxServer(host, port, family)
+      UDP_MUX_LISTENERS.push(udpMuxServer)
     }
 
-    getNetworkAddresses(host, address.port, ipVersion).forEach((ma) => {
-      this.multiaddrs.push(multiaddr(`${ma}/webrtc-direct/certhash/${this.certificate?.certhash}`))
-    })
+    if (family === 4) {
+      udpMuxServer.isIPv4 = true
+    } else if (family === 6) {
+      udpMuxServer.isIPv6 = true
+    }
 
+    this.stunServer = await udpMuxServer.server
+    this.listeningMultiaddr = ma
     this.safeDispatchEvent('listening')
   }
 
-  private startUDPMuxServer (host: string, port: number): UDPMuxServer {
+  private startUDPMuxServer (host: string, port: number, family: 4 | 6): UDPMuxServer {
     return {
       peerId: this.components.peerId,
       owner: this,
       port,
-      isIPv4: isIPv4(host),
-      isIPv6: isIPv6(host),
+      isIPv4: family === 4,
+      isIPv6: family === 6,
       server: Promise.resolve()
         .then(async (): Promise<StunServer> => {
-          // ensure we have a certificate
-          if (this.certificate == null) {
-            this.log.trace('creating TLS certificate')
-            const keyPair = await crypto.subtle.generateKey({
-              name: 'ECDSA',
-              namedCurve: 'P-256'
-            }, true, ['sign', 'verify'])
-
-            const certificate = await generateTransportCertificate(keyPair, {
-              days: 365 * 10
-            })
-
-            if (this.certificate == null) {
-              this.certificate = certificate
-            }
-          }
-
           if (port === 0) {
             // libjuice doesn't map 0 to a random free port so we have to do it
             // ourselves
@@ -247,7 +213,15 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
   }
 
   getAddrs (): Multiaddr[] {
-    return this.multiaddrs
+    if (this.stunServer == null) {
+      return []
+    }
+
+    const address = this.stunServer.address()
+
+    return getThinWaistAddresses(this.listeningMultiaddr, address.port).map(ma => {
+      return ma.encapsulate(`/webrtc-direct/certhash/${this.certificate?.certhash}`)
+    })
   }
 
   updateAnnounceAddrs (multiaddrs: Multiaddr[]): void {
@@ -309,32 +283,3 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     this.safeDispatchEvent('close')
   }
 }
-
-function getNetworkAddresses (host: string, port: number, version: 4 | 6): string[] {
-  if (host === '0.0.0.0' || host === '::') {
-    // return all ip4 interfaces
-    return Object.entries(networkInterfaces())
-      .flatMap(([_, addresses]) => addresses)
-      .map(address => address?.address)
-      .filter(address => {
-        if (address == null) {
-          return false
-        }
-
-        if (version === 4) {
-          return isIPv4(address)
-        }
-
-        if (version === 6) {
-          return isIPv6(address)
-        }
-
-        return false
-      })
-      .map(address => `/ip${version}/${address}/udp/${port}`)
-  }
-
-  return [
-    `/ip${version}/${host}/udp/${port}`
-  ]
-}

package/src/private-to-public/transport.ts

@@ -1,20 +1,30 @@
-import { serviceCapabilities, transportSymbol } from '@libp2p/interface'
+import { generateKeyPair, privateKeyToCryptoKeyPair } from '@libp2p/crypto/keys'
+import { NotFoundError, NotStartedError, TypedEventEmitter, serviceCapabilities, transportSymbol } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
+import { BasicConstraintsExtension, X509Certificate, X509CertificateGenerator } from '@peculiar/x509'
+import { Key } from 'interface-datastore'
+import { base64url } from 'multiformats/bases/base64'
+import { sha256 } from 'multiformats/hashes/sha2'
 import { raceSignal } from 'race-signal'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { DEFAULT_CERTIFICATE_DATASTORE_KEY, DEFAULT_CERTIFICATE_LIFESPAN, DEFAULT_CERTIFICATE_PRIVATE_KEY_NAME } from '../constants.js'
 import { genUfrag } from '../util.js'
 import { WebRTCDirectListener } from './listener.js'
 import { connect } from './utils/connect.js'
 import { createDialerRTCPeerConnection } from './utils/get-rtcpeerconnection.js'
+import { formatAsPem } from './utils/pem.js'
 import type { DataChannelOptions, TransportCertificate } from '../index.js'
 import type { WebRTCDialEvents } from '../private-to-private/transport.js'
-import type { CreateListenerOptions, Transport, Listener, ComponentLogger, Logger, Connection, CounterGroup, Metrics, PeerId, DialTransportOptions, PrivateKey, Upgrader } from '@libp2p/interface'
+import type { CreateListenerOptions, Transport, Listener, ComponentLogger, Logger, Connection, CounterGroup, Metrics, PeerId, DialTransportOptions, PrivateKey, Upgrader, Startable, TypedEventTarget } from '@libp2p/interface'
 import type { TransportManager } from '@libp2p/interface-internal'
+import type { Keychain } from '@libp2p/keychain'
 import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Datastore } from 'interface-datastore'
+
+const ONE_DAY_MS = 86_400_000
 
-/**
- * The peer for this transport
- */
 export interface WebRTCDirectTransportComponents {
   peerId: PeerId
   privateKey: PrivateKey
@@ -22,6 +32,8 @@ export interface WebRTCDirectTransportComponents {
   logger: ComponentLogger
   transportManager: TransportManager
   upgrader: Upgrader
+  keychain?: Keychain
+  datastore: Datastore
 }
 
 export interface WebRTCMetrics {
@@ -29,26 +41,85 @@ export interface WebRTCMetrics {
 }
 
 export interface WebRTCTransportDirectInit {
+  /**
+   * The default configuration used by all created RTCPeerConnections
+   */
   rtcConfiguration?: RTCConfiguration | (() => RTCConfiguration | Promise<RTCConfiguration>)
+
+  /**
+   * The default configuration used by all created RTCDataChannels
+   */
   dataChannel?: DataChannelOptions
+
+  /**
+   * @deprecated use `certificate` instead - this option will be removed in a future release
+   */
   certificates?: TransportCertificate[]
 
+  /**
+   * Use an existing TLS certificate to secure incoming connections or supply
+   * settings to generate one.
+   *
+   * This must be an ECDSA certificate using the P-256 curve.
+   *
+   * From our testing we find that P-256 elliptic curve is supported by Pion,
+   * webrtc-rs, as well as Chromium (P-228 and P-384 was not supported in
+   * Chromium).
+   */
+  certificate?: TransportCertificate
+
   /**
    * @deprecated this setting is ignored and will be removed in a future release
    */
   useLibjuice?: boolean
+
+  /**
+   * The key the certificate is stored in the datastore under
+   *
+   * @default '/libp2p/webrtc-direct/certificate'
+   */
+  certificateDatastoreKey?: string
+
+  /**
+   * The name the certificate private key is stored in the keychain with
+   *
+   * @default 'webrtc-direct-certificate-private-key'
+   */
+  certificateKeychainName?: string
+
+  /**
+   * Number of days a certificate should be valid for
+   *
+   * @default 365
+   */
+  certificateLifespan?: number
+
+  /**
+   * Certificates will be renewed this many days before their expiry
+   *
+   * @default 5
+   */
+  certificateRenewalThreshold?: number
+}
+
+export interface WebRTCDirectTransportCertificateEvents {
+  'certificate:renew': CustomEvent<TransportCertificate>
 }
 
-export class WebRTCDirectTransport implements Transport {
+export class WebRTCDirectTransport implements Transport, Startable {
   private readonly log: Logger
   private readonly metrics?: WebRTCMetrics
   private readonly components: WebRTCDirectTransportComponents
   private readonly init: WebRTCTransportDirectInit
+  private certificate?: TransportCertificate
+  private privateKey?: PrivateKey
+  private readonly emitter: TypedEventTarget<WebRTCDirectTransportCertificateEvents>
 
   constructor (components: WebRTCDirectTransportComponents, init: WebRTCTransportDirectInit = {}) {
     this.log = components.logger.forComponent('libp2p:webrtc-direct')
     this.components = components
     this.init = init
+    this.emitter = new TypedEventEmitter()
 
     if (components.metrics != null) {
       this.metrics = {
@@ -68,6 +139,14 @@ export class WebRTCDirectTransport implements Transport {
     '@libp2p/transport'
   ]
 
+  async start (): Promise<void> {
+    this.certificate = await this.getCertificate()
+  }
+
+  async stop (): Promise<void> {
+
+  }
+
   /**
    * Dial a given multiaddr
    */
@@ -81,9 +160,15 @@ export class WebRTCDirectTransport implements Transport {
    * Create transport listeners no supported by browsers
    */
   createListener (options: CreateListenerOptions): Listener {
+    if (this.certificate == null) {
+      throw new NotStartedError()
+    }
+
     return new WebRTCDirectListener(this.components, {
       ...this.init,
-      ...options
+      ...options,
+      certificate: this.certificate,
+      emitter: this.emitter
     })
   }
 
@@ -139,4 +224,154 @@ export class WebRTCDirectTransport implements Transport {
       throw err
     }
   }
+
+  private async getCertificate (): Promise<TransportCertificate> {
+    if (isTransportCertificate(this.init.certificate)) {
+      this.log.trace('using provided TLS certificate')
+      return this.init.certificate
+    }
+
+    const privateKey = await this.loadOrCreatePrivateKey()
+    const { pem, certhash } = await this.loadOrCreateCertificate(privateKey)
+
+    return {
+      privateKey: await formatAsPem(privateKey),
+      pem,
+      certhash
+    }
+  }
+
+  private async loadOrCreatePrivateKey (): Promise<PrivateKey> {
+    if (this.privateKey != null) {
+      return this.privateKey
+    }
+
+    const keychainName = this.init.certificateKeychainName ?? DEFAULT_CERTIFICATE_PRIVATE_KEY_NAME
+    const keychain = this.getKeychain()
+
+    try {
+      if (keychain == null) {
+        this.log('no keychain configured - not checking for stored private key')
+        throw new NotFoundError()
+      }
+
+      this.log.trace('checking for stored private key')
+      this.privateKey = await keychain.exportKey(keychainName)
+    } catch (err: any) {
+      if (err.name !== 'NotFoundError') {
+        throw err
+      }
+
+      this.log.trace('generating private key')
+      this.privateKey = await generateKeyPair('ECDSA', 'P-256')
+
+      if (keychain != null) {
+        this.log.trace('storing private key')
+        await keychain.importKey(keychainName, this.privateKey)
+      } else {
+        this.log('no keychain configured - not storing private key')
+      }
+    }
+
+    return this.privateKey
+  }
+
+  private async loadOrCreateCertificate (privateKey: PrivateKey): Promise<{ pem: string, certhash: string }> {
+    if (this.certificate != null) {
+      return this.certificate
+    }
+
+    let cert: X509Certificate
+    const dsKey = new Key(this.init.certificateDatastoreKey ?? DEFAULT_CERTIFICATE_DATASTORE_KEY)
+    const keyPair = await privateKeyToCryptoKeyPair(privateKey)
+
+    try {
+      this.log.trace('checking for stored TLS certificate')
+      cert = await this.loadCertificate(dsKey, keyPair)
+    } catch (err: any) {
+      if (err.name !== 'NotFoundError') {
+        throw err
+      }
+
+      this.log('generating TLS certificate using private key')
+      cert = await this.createCertificate(dsKey, keyPair)
+    }
+
+    return {
+      pem: cert.toString('pem'),
+      certhash: base64url.encode((await sha256.digest(new Uint8Array(cert.rawData))).bytes)
+    }
+  }
+
+  async loadCertificate (dsKey: Key, keyPair: CryptoKeyPair): Promise<X509Certificate> {
+    const buf = await this.components.datastore.get(dsKey)
+    const cert = new X509Certificate(buf)
+
+    // check expiry date
+    const threshold = Date.now() - ((this.init.certificateLifespan ?? DEFAULT_CERTIFICATE_LIFESPAN) * ONE_DAY_MS)
+
+    if (cert.notAfter.getTime() < threshold) {
+      this.log('stored TLS certificate has expired')
+      // act as if no certificate was present
+      throw new NotFoundError()
+    }
+
+    // check public keys match
+    const exportedCertKey = await cert.publicKey.export(crypto)
+    const rawCertKey = await crypto.subtle.exportKey('raw', exportedCertKey)
+    const rawKeyPairKey = await crypto.subtle.exportKey('raw', keyPair.publicKey)
+
+    if (!uint8ArrayEquals(
+      new Uint8Array(rawCertKey, 0, rawCertKey.byteLength),
+      new Uint8Array(rawKeyPairKey, 0, rawKeyPairKey.byteLength)
+    )) {
+      this.log('stored TLS certificate public key did not match public key from private key')
+      throw new NotFoundError()
+    }
+
+    return cert
+  }
+
+  async createCertificate (dsKey: Key, keyPair: CryptoKeyPair): Promise<X509Certificate> {
+    const notBefore = new Date()
+    const notAfter = new Date(notBefore.getTime() + ((this.init.certificateLifespan ?? DEFAULT_CERTIFICATE_LIFESPAN) * ONE_DAY_MS))
+
+    // have to set ms to 0 to work around https://github.com/PeculiarVentures/x509/issues/73
+    notBefore.setMilliseconds(0)
+    notAfter.setMilliseconds(0)
+
+    const cert = await X509CertificateGenerator.createSelfSigned({
+      serialNumber: (BigInt(Math.random().toString().replace('.', '')) * 100000n).toString(16),
+      name: 'CN=example.com, C=US, L=CA, O=example, ST=CA',
+      notBefore,
+      notAfter,
+      keys: keyPair,
+      extensions: [
+        new BasicConstraintsExtension(false, undefined, true)
+      ]
+    }, crypto)
+
+    if (this.getKeychain() != null) {
+      this.log.trace('storing TLS certificate')
+      await this.components.datastore.put(dsKey, uint8ArrayFromString(cert.toString('pem')))
+    } else {
+      this.log('no keychain is configured so not storing TLS certificate since the private key will not be reused')
+    }
+
+    return cert
+  }
+
+  private getKeychain (): Keychain | undefined {
+    try {
+      return this.components.keychain
+    } catch {}
+  }
+}
+
+function isTransportCertificate (obj?: any): obj is TransportCertificate {
+  if (obj == null) {
+    return false
+  }
+
+  return typeof obj.privateKey === 'string' && typeof obj.pem === 'string' && typeof obj.certhash === 'string'
 }

package/src/private-to-public/utils/pem.ts

@@ -0,0 +1,18 @@
+import { privateKeyToCryptoKeyPair } from '@libp2p/crypto/keys'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import type { PrivateKey } from '@libp2p/interface'
+
+export function toBuffer (uint8Array: Uint8Array): Buffer {
+  return Buffer.from(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength)
+}
+
+export async function formatAsPem (privateKey: PrivateKey): Promise<string> {
+  const keyPair = await privateKeyToCryptoKeyPair(privateKey)
+  const exported = await crypto.subtle.exportKey('pkcs8', keyPair.privateKey)
+
+  return [
+    '-----BEGIN PRIVATE KEY-----',
+    ...uint8ArrayToString(new Uint8Array(exported), 'base64pad').split(/(.{64})/).filter(Boolean),
+    '-----END PRIVATE KEY-----'
+  ].join('\n')
+}

package/dist/typedoc-urls.json

@@ -1,14 +0,0 @@
-{
-  "DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  ".:DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  "TransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.TransportCertificate.html",
-  ".:TransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.TransportCertificate.html",
-  "WebRTCDirectTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCDirectTransportComponents.html",
-  "WebRTCTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportComponents.html",
-  "WebRTCTransportDirectInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportDirectInit.html",
-  "WebRTCTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportInit.html",
-  "webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  ".:webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  "webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html",
-  ".:webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html"
-}