web-dc-api 0.0.62 → 0.0.64

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/private-to-private/transport.js

@@ -1,221 +0,0 @@
-'use strict';
-
-var index = require('../../../../interface/dist/src/index.js');
-var index$3 = require('../../../../peer-id/dist/src/index.js');
-var index$2 = require('../../../../../@multiformats/multiaddr/dist/src/index.js');
-var index$1 = require('../../../../../@multiformats/multiaddr-matcher/dist/src/index.js');
-var constants = require('../constants.js');
-var maconn = require('../maconn.js');
-var muxer = require('../muxer.js');
-var util = require('../util.js');
-var index_browser = require('../webrtc/index.browser.js');
-var initiateConnection = require('./initiate-connection.js');
-var listener = require('./listener.js');
-var signalingStreamHandler = require('./signaling-stream-handler.js');
-var events_browser = require('../../../../interface/dist/src/events.browser.js');
-var transport = require('../../../../interface/dist/src/transport.js');
-var errors = require('../../../../interface/dist/src/errors.js');
-
-class WebRTCTransport {
-  components;
-  init;
-  log;
-  _started = false;
-  metrics;
-  shutdownController;
-  constructor(components) {
-    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    this.components = components;
-    this.init = init;
-    this.log = components.logger.forComponent('libp2p:webrtc');
-    this.shutdownController = new AbortController();
-    events_browser.setMaxListeners(Infinity, this.shutdownController.signal);
-    if (components.metrics != null) {
-      this.metrics = {
-        dialerEvents: components.metrics.registerCounterGroup('libp2p_webrtc_dialer_events_total', {
-          label: 'event',
-          help: 'Total count of WebRTC dialer events by type'
-        }),
-        listenerEvents: components.metrics.registerCounterGroup('libp2p_webrtc_listener_events_total', {
-          label: 'event',
-          help: 'Total count of WebRTC listener events by type'
-        })
-      };
-    }
-  }
-  [transport.transportSymbol] = true;
-  [Symbol.toStringTag] = '@libp2p/webrtc';
-  [index.serviceCapabilities] = ['@libp2p/transport'];
-  [index.serviceDependencies] = ['@libp2p/identify', '@libp2p/circuit-relay-v2-transport'];
-  isStarted() {
-    return this._started;
-  }
-  async start() {
-    await this.components.registrar.handle(constants.SIGNALING_PROTOCOL, data => {
-      // ensure we don't try to upgrade forever
-      const signal = this.components.upgrader.createInboundAbortSignal(this.shutdownController.signal);
-      this._onProtocol(data, signal).catch(err => {
-        this.log.error('failed to handle incoming connect from %p', data.connection.remotePeer, err);
-      }).finally(() => {
-        signal.clear();
-      });
-    }, {
-      runOnLimitedConnection: true
-    });
-    this._started = true;
-  }
-  async stop() {
-    await this.components.registrar.unhandle(constants.SIGNALING_PROTOCOL);
-    this._started = false;
-  }
-  createListener(options) {
-    return new listener.WebRTCPeerListener(this.components, {
-      shutdownController: this.shutdownController
-    });
-  }
-  /**
-   * Filter check for all Multiaddrs that this transport can listen on
-   */
-  listenFilter(multiaddrs) {
-    return multiaddrs.filter(index$1.WebRTC.exactMatch);
-  }
-  /**
-   * Filter check for all Multiaddrs that this transport can dial
-   */
-  dialFilter(multiaddrs) {
-    return this.listenFilter(multiaddrs);
-  }
-  /*
-   * dial connects to a remote via the circuit relay or any other protocol
-   * and proceeds to upgrade to a webrtc connection.
-   * multiaddr of the form: <multiaddr>/webrtc/p2p/<destination-peer>
-   * For a circuit relay, this will be of the form
-   * <relay address>/p2p/<relay-peer>/p2p-circuit/webrtc/p2p/<destination-peer>
-  */
-  async dial(ma, options) {
-    this.log.trace('dialing address: %a', ma);
-    const {
-      remoteAddress,
-      peerConnection,
-      muxerFactory
-    } = await initiateConnection.initiateConnection({
-      rtcConfiguration: await util.getRtcConfiguration(this.init.rtcConfiguration),
-      dataChannel: this.init.dataChannel,
-      multiaddr: ma,
-      dataChannelOptions: this.init.dataChannel,
-      signal: options.signal,
-      connectionManager: this.components.connectionManager,
-      transportManager: this.components.transportManager,
-      log: this.log,
-      logger: this.components.logger,
-      onProgress: options.onProgress
-    });
-    const webRTCConn = new maconn.WebRTCMultiaddrConnection(this.components, {
-      peerConnection,
-      timeline: {
-        open: Date.now()
-      },
-      remoteAddr: remoteAddress,
-      metrics: this.metrics?.dialerEvents
-    });
-    const connection = await options.upgrader.upgradeOutbound(webRTCConn, {
-      skipProtection: true,
-      skipEncryption: true,
-      muxerFactory,
-      onProgress: options.onProgress,
-      signal: options.signal
-    });
-    // close the connection on shut down
-    this._closeOnShutdown(peerConnection, webRTCConn);
-    return connection;
-  }
-  async _onProtocol(_ref, signal) {
-    let {
-      connection,
-      stream
-    } = _ref;
-    const peerConnection = new index_browser.RTCPeerConnection(await util.getRtcConfiguration(this.init.rtcConfiguration));
-    const muxerFactory = new muxer.DataChannelMuxerFactory(this.components, {
-      peerConnection,
-      dataChannelOptions: this.init.dataChannel
-    });
-    try {
-      const {
-        remoteAddress
-      } = await signalingStreamHandler.handleIncomingStream({
-        peerConnection,
-        connection,
-        stream,
-        signal,
-        log: this.log
-      });
-      // close the stream if SDP messages have been exchanged successfully
-      await stream.close({
-        signal
-      });
-      const webRTCConn = new maconn.WebRTCMultiaddrConnection(this.components, {
-        peerConnection,
-        timeline: {
-          open: new Date().getTime()
-        },
-        remoteAddr: remoteAddress,
-        metrics: this.metrics?.listenerEvents
-      });
-      await this.components.upgrader.upgradeInbound(webRTCConn, {
-        skipEncryption: true,
-        skipProtection: true,
-        muxerFactory,
-        signal
-      });
-      // close the connection on shut down
-      this._closeOnShutdown(peerConnection, webRTCConn);
-    } catch (err) {
-      this.log.error('incoming signaling error', err);
-      peerConnection.close();
-      stream.abort(err);
-      throw err;
-    }
-  }
-  _closeOnShutdown(pc, webRTCConn) {
-    // close the connection on shut down
-    const shutDownListener = () => {
-      webRTCConn.close().catch(err => {
-        this.log.error('could not close WebRTCMultiaddrConnection', err);
-      });
-    };
-    this.shutdownController.signal.addEventListener('abort', shutDownListener);
-    pc.addEventListener('close', () => {
-      this.shutdownController.signal.removeEventListener('abort', shutDownListener);
-    });
-  }
-}
-function splitAddr(ma) {
-  const addrs = ma.toString().split('/webrtc/');
-  if (addrs.length !== 2) {
-    throw new errors.InvalidParametersError('webrtc protocol was not present in multiaddr');
-  }
-  if (!addrs[0].includes('/p2p-circuit')) {
-    throw new errors.InvalidParametersError('p2p-circuit protocol was not present in multiaddr');
-  }
-  // look for remote peerId
-  let remoteAddr = index$2.multiaddr(addrs[0]);
-  const destination = index$2.multiaddr('/' + addrs[1]);
-  const destinationIdString = destination.getPeerId();
-  if (destinationIdString == null) {
-    throw new errors.InvalidParametersError('destination peer id was missing');
-  }
-  const lastProtoInRemote = remoteAddr.protos().pop();
-  if (lastProtoInRemote === undefined) {
-    throw new errors.InvalidParametersError('invalid multiaddr');
-  }
-  if (lastProtoInRemote.name !== 'p2p') {
-    remoteAddr = remoteAddr.encapsulate(`/p2p/${destinationIdString}`);
-  }
-  return {
-    baseAddr: remoteAddr,
-    peerId: index$3.peerIdFromString(destinationIdString)
-  };
-}
-
-exports.WebRTCTransport = WebRTCTransport;
-exports.splitAddr = splitAddr;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/private-to-private/util.js

@@ -1,73 +0,0 @@
-'use strict';
-
-var index = require('../../../../../p-defer/index.js');
-var index$1 = require('../../../../../progress-events/dist/src/index.js');
-var util = require('../util.js');
-var index_browser = require('../webrtc/index.browser.js');
-var message = require('./pb/message.js');
-var errors = require('../../../../interface/dist/src/errors.js');
-
-const readCandidatesUntilConnected = async (pc, stream, options) => {
-  try {
-    const connectedPromise = index.default();
-    resolveOnConnected(pc, connectedPromise);
-    // read candidates until we are connected or we reach the end of the stream
-    while (true) {
-      // if we connect, stop trying to read from the stream
-      const message$1 = await Promise.race([connectedPromise.promise, stream.read({
-        signal: options.signal
-      }).catch(() => {})]);
-      // stream ended or we became connected
-      if (message$1 == null) {
-        // throw if we timed out
-        options.signal?.throwIfAborted();
-        break;
-      }
-      if (message$1.type !== message.Message.Type.ICE_CANDIDATE) {
-        throw new errors.InvalidMessageError('ICE candidate message expected');
-      }
-      const candidateInit = JSON.parse(message$1.data ?? 'null');
-      // an empty string means this generation of candidates is complete, a null
-      // candidate means candidate gathering has finished
-      // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
-      if (candidateInit === '' || candidateInit === null) {
-        options.onProgress?.(new index$1.CustomProgressEvent('webrtc:end-of-ice-candidates'));
-        options.log.trace('end-of-candidates received');
-        continue;
-      }
-      const candidate = new index_browser.RTCIceCandidate(candidateInit);
-      options.log.trace('%s received new ICE candidate %o', options.direction, candidateInit);
-      try {
-        options.onProgress?.(new index$1.CustomProgressEvent('webrtc:add-ice-candidate', candidate.candidate));
-        await pc.addIceCandidate(candidate);
-      } catch (err) {
-        options.log.error('%s bad candidate received', options.direction, candidateInit, err);
-      }
-    }
-  } catch (err) {
-    options.log.error('%s error parsing ICE candidate', options.direction, err);
-    if (options.signal?.aborted === true && getConnectionState(pc) !== 'connected') {
-      throw err;
-    }
-  }
-};
-function getConnectionState(pc) {
-  return util.isFirefox ? pc.iceConnectionState : pc.connectionState;
-}
-function resolveOnConnected(pc, promise) {
-  pc[util.isFirefox ? 'oniceconnectionstatechange' : 'onconnectionstatechange'] = _ => {
-    switch (getConnectionState(pc)) {
-      case 'connected':
-        promise.resolve();
-        break;
-      case 'failed':
-      case 'disconnected':
-      case 'closed':
-        promise.reject(new errors.ConnectionFailedError('RTCPeerConnection was closed'));
-        break;
-    }
-  };
-}
-
-exports.getConnectionState = getConnectionState;
-exports.readCandidatesUntilConnected = readCandidatesUntilConnected;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/private-to-public/listener.browser.js

@@ -1,17 +0,0 @@
-'use strict';
-
-var error = require('../error.js');
-var eventTarget = require('../../../../interface/dist/src/event-target.js');
-
-class WebRTCDirectListener extends eventTarget.TypedEventEmitter {
-  async listen() {
-    throw new error.UnimplementedError('WebRTCTransport.createListener');
-  }
-  getAddrs() {
-    return [];
-  }
-  updateAnnounceAddrs() {}
-  async close() {}
-}
-
-exports.WebRTCDirectListener = WebRTCDirectListener;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/private-to-public/pb/message.js

@@ -1,84 +0,0 @@
-'use strict';
-
-var decode = require('../../../../../../protons-runtime/dist/src/decode.js');
-var encode = require('../../../../../../protons-runtime/dist/src/encode.js');
-var _enum = require('../../../../../../protons-runtime/dist/src/codecs/enum.js');
-var message = require('../../../../../../protons-runtime/dist/src/codecs/message.js');
-require('../../../../../../protons-runtime/dist/src/utils/float.js');
-require('../../../../../../protons-runtime/dist/src/utils/longbits.js');
-require('../../../../../../protons-runtime/dist/src/utils/writer.js');
-
-exports.Message = void 0;
-(function (Message) {
-  (function (Flag) {
-    Flag["FIN"] = "FIN";
-    Flag["STOP_SENDING"] = "STOP_SENDING";
-    Flag["RESET"] = "RESET";
-    Flag["FIN_ACK"] = "FIN_ACK";
-  })(Message.Flag || (Message.Flag = {}));
-  let __FlagValues;
-  (function (__FlagValues) {
-    __FlagValues[__FlagValues["FIN"] = 0] = "FIN";
-    __FlagValues[__FlagValues["STOP_SENDING"] = 1] = "STOP_SENDING";
-    __FlagValues[__FlagValues["RESET"] = 2] = "RESET";
-    __FlagValues[__FlagValues["FIN_ACK"] = 3] = "FIN_ACK";
-  })(__FlagValues || (__FlagValues = {}));
-  (function (Flag) {
-    Flag.codec = () => {
-      return _enum.enumeration(__FlagValues);
-    };
-  })(Message.Flag || (Message.Flag = {}));
-  let _codec;
-  Message.codec = () => {
-    if (_codec == null) {
-      _codec = message.message(function (obj, w) {
-        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-        if (opts.lengthDelimited !== false) {
-          w.fork();
-        }
-        if (obj.flag != null) {
-          w.uint32(8);
-          Message.Flag.codec().encode(obj.flag, w);
-        }
-        if (obj.message != null) {
-          w.uint32(18);
-          w.bytes(obj.message);
-        }
-        if (opts.lengthDelimited !== false) {
-          w.ldelim();
-        }
-      }, function (reader, length) {
-        const obj = {};
-        const end = length == null ? reader.len : reader.pos + length;
-        while (reader.pos < end) {
-          const tag = reader.uint32();
-          switch (tag >>> 3) {
-            case 1:
-              {
-                obj.flag = Message.Flag.codec().decode(reader);
-                break;
-              }
-            case 2:
-              {
-                obj.message = reader.bytes();
-                break;
-              }
-            default:
-              {
-                reader.skipType(tag & 7);
-                break;
-              }
-          }
-        }
-        return obj;
-      });
-    }
-    return _codec;
-  };
-  Message.encode = obj => {
-    return encode.encodeMessage(obj, Message.codec());
-  };
-  Message.decode = (buf, opts) => {
-    return decode.decodeMessage(buf, Message.codec(), opts);
-  };
-})(exports.Message || (exports.Message = {}));

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/private-to-public/transport.js

@@ -1,267 +0,0 @@
-'use strict';
-
-var index$3 = require('../../../../crypto/dist/src/keys/index.js');
-var index = require('../../../../interface/dist/src/index.js');
-var index$1 = require('../../../../peer-id/dist/src/index.js');
-var index$2 = require('../../../../../@multiformats/multiaddr-matcher/dist/src/index.js');
-var x509_es = require('../../../../../@peculiar/x509/build/x509.es.js');
-var key = require('../../../../../interface-datastore/dist/src/key.js');
-var base64 = require('../../../../../multiformats/dist/src/bases/base64.js');
-var sha2Browser = require('../../../../../multiformats/dist/src/hashes/sha2-browser.js');
-var equals = require('../../../../../uint8arrays/dist/src/equals.js');
-var fromString = require('../../../../../uint8arrays/dist/src/from-string.js');
-var constants = require('../constants.js');
-var util = require('../util.js');
-var listener_browser = require('./listener.browser.js');
-var connect = require('./utils/connect.js');
-var getRtcpeerconnection_browser = require('./utils/get-rtcpeerconnection.browser.js');
-var pem = require('./utils/pem.js');
-var errors = require('../../../../interface/dist/src/errors.js');
-var eventTarget = require('../../../../interface/dist/src/event-target.js');
-var transport = require('../../../../interface/dist/src/transport.js');
-
-class WebRTCDirectTransport {
-  log;
-  metrics;
-  components;
-  init;
-  certificate;
-  privateKey;
-  emitter;
-  renewCertificateTask;
-  constructor(components) {
-    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    this.log = components.logger.forComponent('libp2p:webrtc-direct');
-    this.components = components;
-    this.init = init;
-    this.emitter = new eventTarget.TypedEventEmitter();
-    if (init.certificateLifespan != null && init.certificateRenewalThreshold != null && init.certificateRenewalThreshold >= init.certificateLifespan) {
-      throw new errors.InvalidParametersError('Certificate renewal threshold must be less than certificate lifespan');
-    }
-    if (components.metrics != null) {
-      this.metrics = {
-        dialerEvents: components.metrics.registerCounterGroup('libp2p_webrtc-direct_dialer_events_total', {
-          label: 'event',
-          help: 'Total count of WebRTC-direct dial events by type'
-        })
-      };
-    }
-  }
-  [transport.transportSymbol] = true;
-  [Symbol.toStringTag] = '@libp2p/webrtc-direct';
-  [index.serviceCapabilities] = ['@libp2p/transport'];
-  async start() {
-    this.certificate = await this.getCertificate();
-  }
-  async stop() {
-    if (this.renewCertificateTask != null) {
-      clearTimeout(this.renewCertificateTask);
-    }
-    this.certificate = undefined;
-  }
-  /**
-   * Dial a given multiaddr
-   */
-  async dial(ma, options) {
-    this.log('dial %a', ma);
-    // do not create RTCPeerConnection if the signal has already been aborted
-    options.signal.throwIfAborted();
-    let theirPeerId;
-    const remotePeerString = ma.getPeerId();
-    if (remotePeerString != null) {
-      theirPeerId = index$1.peerIdFromString(remotePeerString);
-    }
-    const ufrag = util.genUfrag();
-    // https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md#browser-to-public-server
-    const peerConnection = await getRtcpeerconnection_browser.createDialerRTCPeerConnection('client', ufrag, typeof this.init.rtcConfiguration === 'function' ? await this.init.rtcConfiguration() : this.init.rtcConfiguration ?? {});
-    try {
-      return await connect.connect(peerConnection, ufrag, {
-        role: 'client',
-        log: this.log,
-        logger: this.components.logger,
-        metrics: this.components.metrics,
-        events: this.metrics?.dialerEvents,
-        signal: options.signal,
-        remoteAddr: ma,
-        dataChannel: this.init.dataChannel,
-        upgrader: options.upgrader,
-        peerId: this.components.peerId,
-        remotePeerId: theirPeerId,
-        privateKey: this.components.privateKey
-      });
-    } catch (err) {
-      peerConnection.close();
-      throw err;
-    }
-  }
-  /**
-   * Create a transport listener - this will throw in browsers
-   */
-  createListener(options) {
-    if (this.certificate == null) {
-      throw new errors.NotStartedError();
-    }
-    return new listener_browser.WebRTCDirectListener(this.components, {
-      ...this.init,
-      ...options,
-      certificate: this.certificate,
-      emitter: this.emitter
-    });
-  }
-  /**
-   * Filter check for all Multiaddrs that this transport can listen on
-   */
-  listenFilter(multiaddrs) {
-    return multiaddrs.filter(index$2.WebRTCDirect.exactMatch);
-  }
-  /**
-   * Filter check for all Multiaddrs that this transport can dial
-   */
-  dialFilter(multiaddrs) {
-    return this.listenFilter(multiaddrs);
-  }
-  async getCertificate(forceRenew) {
-    if (isTransportCertificate(this.init.certificate)) {
-      this.log('using provided TLS certificate');
-      return this.init.certificate;
-    }
-    const privateKey = await this.loadOrCreatePrivateKey();
-    const {
-      pem: pem$1,
-      certhash
-    } = await this.loadOrCreateCertificate(privateKey, forceRenew);
-    return {
-      privateKey: await pem.formatAsPem(privateKey),
-      pem: pem$1,
-      certhash
-    };
-  }
-  async loadOrCreatePrivateKey() {
-    if (this.privateKey != null) {
-      return this.privateKey;
-    }
-    const keychainName = this.init.certificateKeychainName ?? constants.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 errors.NotFoundError();
-      }
-      this.log.trace('checking for stored private key');
-      this.privateKey = await keychain.exportKey(keychainName);
-    } catch (err) {
-      if (err.name !== 'NotFoundError') {
-        throw err;
-      }
-      this.log.trace('generating private key');
-      this.privateKey = await index$3.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;
-  }
-  async loadOrCreateCertificate(privateKey, forceRenew) {
-    if (this.certificate != null && forceRenew !== true) {
-      return this.certificate;
-    }
-    let cert;
-    const dsKey = new key.Key(this.init.certificateDatastoreKey ?? constants.DEFAULT_CERTIFICATE_DATASTORE_KEY);
-    const keyPair = await index$3.privateKeyToCryptoKeyPair(privateKey);
-    try {
-      if (forceRenew === true) {
-        this.log.trace('forcing renewal of TLS certificate');
-        throw new errors.NotFoundError();
-      }
-      this.log.trace('checking for stored TLS certificate');
-      cert = await this.loadCertificate(dsKey, keyPair);
-    } catch (err) {
-      if (err.name !== 'NotFoundError') {
-        throw err;
-      }
-      this.log.trace('generating new TLS certificate');
-      cert = await this.createCertificate(dsKey, keyPair);
-    }
-    // set timeout to renew certificate
-    let renewTime = cert.notAfter.getTime() - (this.init.certificateRenewalThreshold ?? constants.DEFAULT_CERTIFICATE_RENEWAL_THRESHOLD) - Date.now();
-    if (renewTime < 0) {
-      renewTime = 100;
-    }
-    this.log('will renew TLS certificate after %d ms', renewTime);
-    this.renewCertificateTask = setTimeout(() => {
-      this.log('renewing TLS certificate');
-      this.getCertificate(true).then(cert => {
-        this.certificate = cert;
-        this.emitter.safeDispatchEvent('certificate:renew', {
-          detail: cert
-        });
-      }).catch(err => {
-        this.log.error('could not renew certificate - %e', err);
-      });
-    }, renewTime);
-    return {
-      pem: cert.toString('pem'),
-      certhash: base64.base64url.encode((await sha2Browser.sha256.digest(new Uint8Array(cert.rawData))).bytes)
-    };
-  }
-  async loadCertificate(dsKey, keyPair) {
-    const buf = await this.components.datastore.get(dsKey);
-    const cert = new x509_es.X509Certificate(buf);
-    // check expiry date
-    const expiryTime = cert.notAfter.getTime() - (this.init.certificateRenewalThreshold ?? constants.DEFAULT_CERTIFICATE_RENEWAL_THRESHOLD);
-    if (Date.now() > expiryTime) {
-      this.log('stored TLS certificate has expired');
-      // act as if no certificate was present
-      throw new errors.NotFoundError();
-    }
-    this.log('loaded certificate, expires in %d ms', expiryTime);
-    // 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 (!equals.equals(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 errors.NotFoundError();
-    }
-    this.log('loaded certificate, expiry time is %o', expiryTime);
-    return cert;
-  }
-  async createCertificate(dsKey, keyPair) {
-    const notBefore = new Date();
-    const notAfter = new Date(Date.now() + (this.init.certificateLifespan ?? constants.DEFAULT_CERTIFICATE_LIFESPAN));
-    // 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 x509_es.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 x509_es.BasicConstraintsExtension(false, undefined, true)]
-    }, crypto);
-    if (this.getKeychain() != null) {
-      this.log.trace('storing TLS certificate');
-      await this.components.datastore.put(dsKey, fromString.fromString(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;
-  }
-  getKeychain() {
-    try {
-      return this.components.keychain;
-    } catch {}
-  }
-}
-function isTransportCertificate(obj) {
-  if (obj == null) {
-    return false;
-  }
-  return typeof obj.privateKey === 'string' && typeof obj.pem === 'string' && typeof obj.certhash === 'string';
-}
-
-exports.WebRTCDirectTransport = WebRTCDirectTransport;