web-dc-api 0.0.61 → 0.0.62

package/dist/esm/node_modules/@libp2p/utils/dist/src/merge-options.js

@@ -0,0 +1,139 @@
+import isPlainObject from '../../../../is-plain-obj/index.js';
+
+const {
+  hasOwnProperty
+} = Object.prototype;
+const {
+  propertyIsEnumerable
+} = Object;
+const defineProperty = (object, name, value) => {
+  Object.defineProperty(object, name, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+};
+const globalThis = undefined;
+const defaultMergeOptions = {
+  concatArrays: false,
+  ignoreUndefined: false
+};
+const getEnumerableOwnPropertyKeys = value => {
+  const keys = [];
+  for (const key in value) {
+    if (hasOwnProperty.call(value, key)) {
+      keys.push(key);
+    }
+  }
+  /* istanbul ignore else  */
+  if (Object.getOwnPropertySymbols) {
+    const symbols = Object.getOwnPropertySymbols(value);
+    for (const symbol of symbols) {
+      if (propertyIsEnumerable.call(value, symbol)) {
+        keys.push(symbol);
+      }
+    }
+  }
+  return keys;
+};
+function clone(value) {
+  if (Array.isArray(value)) {
+    return cloneArray(value);
+  }
+  if (isPlainObject(value)) {
+    return cloneOptionObject(value);
+  }
+  return value;
+}
+function cloneArray(array) {
+  const result = array.slice(0, 0);
+  getEnumerableOwnPropertyKeys(array).forEach(key => {
+    defineProperty(result, key, clone(array[key]));
+  });
+  return result;
+}
+function cloneOptionObject(object) {
+  const result = Object.getPrototypeOf(object) === null ? Object.create(null) : {};
+  getEnumerableOwnPropertyKeys(object).forEach(key => {
+    defineProperty(result, key, clone(object[key]));
+  });
+  return result;
+}
+const mergeKeys = (merged, source, keys, config) => {
+  keys.forEach(key => {
+    if (typeof source[key] === 'undefined' && config.ignoreUndefined) {
+      return;
+    }
+    // Do not recurse into prototype chain of merged
+    if (key in merged && merged[key] !== Object.getPrototypeOf(merged)) {
+      defineProperty(merged, key, merge(merged[key], source[key], config));
+    } else {
+      defineProperty(merged, key, clone(source[key]));
+    }
+  });
+  return merged;
+};
+/**
+ * see [Array.prototype.concat ( ...arguments )](http://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.concat)
+ */
+const concatArrays = (merged, source, config) => {
+  let result = merged.slice(0, 0);
+  let resultIndex = 0;
+  [merged, source].forEach(array => {
+    const indices = [];
+    // `result.concat(array)` with cloning
+    for (let k = 0; k < array.length; k++) {
+      if (!hasOwnProperty.call(array, k)) {
+        continue;
+      }
+      indices.push(String(k));
+      if (array === merged) {
+        // Already cloned
+        defineProperty(result, resultIndex++, array[k]);
+      } else {
+        defineProperty(result, resultIndex++, clone(array[k]));
+      }
+    }
+    // Merge non-index keys
+    result = mergeKeys(result, array, getEnumerableOwnPropertyKeys(array).filter(key => !indices.includes(key)), config);
+  });
+  return result;
+};
+function merge(merged, source, config) {
+  if (config.concatArrays && Array.isArray(merged) && Array.isArray(source)) {
+    return concatArrays(merged, source, config);
+  }
+  if (!isPlainObject(source) || !isPlainObject(merged)) {
+    return clone(source);
+  }
+  return mergeKeys(merged, source, getEnumerableOwnPropertyKeys(source), config);
+}
+/**
+ * Port of `merge-options` to typescript
+ *
+ * @see https://github.com/schnittstabil/merge-options/pull/28
+ */
+function mergeOptions() {
+  const config = merge(clone(defaultMergeOptions), this !== globalThis && this || {}, defaultMergeOptions);
+  let merged = {
+    _: {}
+  };
+  for (var _len = arguments.length, options = new Array(_len), _key = 0; _key < _len; _key++) {
+    options[_key] = arguments[_key];
+  }
+  for (const option of options) {
+    if (option === undefined) {
+      continue;
+    }
+    if (!isPlainObject(option)) {
+      throw new TypeError('`' + option + '` is not an Option Object');
+    }
+    merged = merge(merged, {
+      _: option
+    }, config);
+  }
+  return merged._;
+}
+
+export { mergeOptions };

package/dist/esm/node_modules/@libp2p/utils/dist/src/moving-average.js

@@ -0,0 +1,44 @@
+/**
+ * Implements exponential moving average. Ported from `moving-average`.
+ *
+ * @see https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
+ * @see https://www.npmjs.com/package/moving-average
+ */
+class MovingAverage {
+  movingAverage;
+  variance;
+  deviation;
+  forecast;
+  timeSpan;
+  previousTime;
+  constructor(timeSpan) {
+    this.timeSpan = timeSpan;
+    this.movingAverage = 0;
+    this.variance = 0;
+    this.deviation = 0;
+    this.forecast = 0;
+  }
+  alpha(t, pt) {
+    return 1 - Math.exp(-(t - pt) / this.timeSpan);
+  }
+  push(value) {
+    let time = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Date.now();
+    if (this.previousTime != null) {
+      // calculate moving average
+      const a = this.alpha(time, this.previousTime);
+      const diff = value - this.movingAverage;
+      const incr = a * diff;
+      this.movingAverage = a * value + (1 - a) * this.movingAverage;
+      // calculate variance & deviation
+      this.variance = (1 - a) * (this.variance + diff * incr);
+      this.deviation = Math.sqrt(this.variance);
+      // calculate forecast
+      this.forecast = this.movingAverage + a * diff;
+    } else {
+      this.movingAverage = value;
+    }
+    this.previousTime = time;
+  }
+}
+
+export { MovingAverage };

package/dist/esm/node_modules/@libp2p/utils/dist/src/multiaddr/is-link-local.js

@@ -0,0 +1,22 @@
+const CODEC_IP4 = 0x04;
+const CODEC_IP6 = 0x29;
+/**
+ * Check if a given multiaddr is a link-local address
+ */
+function isLinkLocal(ma) {
+  try {
+    const [[codec, value]] = ma.stringTuples();
+    if (value == null) {
+      return false;
+    }
+    if (codec === CODEC_IP4) {
+      return value.startsWith('169.254.');
+    }
+    if (codec === CODEC_IP6) {
+      return value.toLowerCase().startsWith('fe80');
+    }
+  } catch {}
+  return false;
+}
+
+export { isLinkLocal };

package/dist/esm/node_modules/@libp2p/utils/dist/src/multiaddr/is-loopback.js

@@ -0,0 +1,18 @@
+import { isLoopbackAddr } from '../../../../../is-loopback-addr/dist/src/index.js';
+import { isIpBased } from './is-ip-based.js';
+
+/**
+ * Check if a given multiaddr is a loopback address.
+ */
+function isLoopback(ma) {
+  if (!isIpBased(ma)) {
+    // not an IP based multiaddr, cannot be private
+    return false;
+  }
+  const {
+    address
+  } = ma.nodeAddress();
+  return isLoopbackAddr(address);
+}
+
+export { isLoopback };

package/dist/esm/node_modules/@libp2p/utils/dist/src/multiaddr/is-network-address.js

@@ -0,0 +1,19 @@
+const CODEC_IP4 = 0x04;
+const CODEC_IP6 = 0x29;
+const CODEC_DNS = 0x35;
+const CODEC_DNS4 = 0x36;
+const CODEC_DNS6 = 0x37;
+const CODEC_DNSADDR = 0x38;
+const NETWORK_CODECS = [CODEC_IP4, CODEC_IP6, CODEC_DNS, CODEC_DNS4, CODEC_DNS6, CODEC_DNSADDR];
+/**
+ * Check if a given multiaddr is a network address
+ */
+function isNetworkAddress(ma) {
+  try {
+    const [[codec]] = ma.stringTuples();
+    return NETWORK_CODECS.includes(codec);
+  } catch {}
+  return false;
+}
+
+export { isNetworkAddress };

package/dist/esm/node_modules/@libp2p/utils/dist/src/priority-queue.js

@@ -0,0 +1,21 @@
+import { Queue } from './queue/index.js';
+
+class PriorityQueue extends Queue {
+  constructor() {
+    let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    super({
+      ...init,
+      sort: (a, b) => {
+        if (a.options.priority > b.options.priority) {
+          return -1;
+        }
+        if (a.options.priority < b.options.priority) {
+          return 1;
+        }
+        return 0;
+      }
+    });
+  }
+}
+
+export { PriorityQueue };

package/dist/esm/node_modules/@libp2p/utils/dist/src/queue/index.js

@@ -1,9 +1,10 @@
-import { TypedEventEmitter, AbortError } from '@libp2p/interface';
 import { pushable } from '../../../../../it-pushable/dist/src/index.js';
 import { raceEvent } from '../../../../../race-event/dist/src/index.js';
 import { debounce } from '../debounce.js';
 import { QueueFullError } from '../errors.js';
 import { Job } from './job.js';
+import { TypedEventEmitter } from '../../../../interface/dist/src/event-target.js';
+import { AbortError } from '../../../../interface/dist/src/errors.js';
 
 /**
  * Heavily influence by `p-queue` with the following differences:

package/dist/esm/node_modules/@libp2p/utils/dist/src/queue/job.js

@@ -1,6 +1,7 @@
-import { setMaxListeners, AbortError } from '@libp2p/interface';
 import { raceSignal } from '../../../../../race-signal/dist/src/index.js';
 import { JobRecipient } from './recipient.js';
+import { setMaxListeners } from '../../../../interface/dist/src/events.browser.js';
+import { AbortError } from '../../../../interface/dist/src/errors.js';
 
 /**
  * Returns a random string

package/dist/esm/node_modules/@libp2p/utils/dist/src/queue/recipient.js

@@ -1,5 +1,5 @@
-import { AbortError } from '@libp2p/interface';
 import pDefer from '../../../../../p-defer/index.js';
+import { AbortError } from '../../../../interface/dist/src/errors.js';
 
 class JobRecipient {
   deferred;

package/dist/esm/node_modules/@libp2p/utils/dist/src/rate-limiter.js

@@ -0,0 +1,189 @@
+import delay from '../../../../delay/index.js';
+import { RateLimitError } from './errors.js';
+
+class RateLimiter {
+  memoryStorage;
+  points;
+  duration;
+  blockDuration;
+  execEvenly;
+  execEvenlyMinDelayMs;
+  keyPrefix;
+  constructor() {
+    let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    this.points = opts.points ?? 4;
+    this.duration = opts.duration ?? 1;
+    this.blockDuration = opts.blockDuration ?? 0;
+    this.execEvenly = opts.execEvenly ?? false;
+    this.execEvenlyMinDelayMs = opts.execEvenlyMinDelayMs ?? this.duration * 1000 / this.points;
+    this.keyPrefix = opts.keyPrefix ?? 'rlflx';
+    this.memoryStorage = new MemoryStorage();
+  }
+  async consume(key) {
+    let pointsToConsume = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const rlKey = this.getKey(key);
+    const secDuration = this._getKeySecDuration(options);
+    let res = this.memoryStorage.incrby(rlKey, pointsToConsume, secDuration);
+    res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+    if (res.consumedPoints > this.points) {
+      // Block only first time when consumed more than points
+      if (this.blockDuration > 0 && res.consumedPoints <= this.points + pointsToConsume) {
+        // Block key
+        res = this.memoryStorage.set(rlKey, res.consumedPoints, this.blockDuration);
+      }
+      throw new RateLimitError('Rate limit exceeded', res);
+    } else if (this.execEvenly && res.msBeforeNext > 0 && !res.isFirstInDuration) {
+      // Execute evenly
+      let delayMs = Math.ceil(res.msBeforeNext / (res.remainingPoints + 2));
+      if (delayMs < this.execEvenlyMinDelayMs) {
+        delayMs = res.consumedPoints * this.execEvenlyMinDelayMs;
+      }
+      await delay(delayMs);
+    }
+    return res;
+  }
+  penalty(key) {
+    let points = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const rlKey = this.getKey(key);
+    const secDuration = this._getKeySecDuration(options);
+    const res = this.memoryStorage.incrby(rlKey, points, secDuration);
+    res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+    return res;
+  }
+  reward(key) {
+    let points = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const rlKey = this.getKey(key);
+    const secDuration = this._getKeySecDuration(options);
+    const res = this.memoryStorage.incrby(rlKey, -points, secDuration);
+    res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+    return res;
+  }
+  /**
+   * Block any key for secDuration seconds
+   *
+   * @param key
+   * @param secDuration
+   */
+  block(key, secDuration) {
+    const msDuration = secDuration * 1000;
+    const initPoints = this.points + 1;
+    this.memoryStorage.set(this.getKey(key), initPoints, secDuration);
+    return {
+      remainingPoints: 0,
+      msBeforeNext: msDuration === 0 ? -1 : msDuration,
+      consumedPoints: initPoints,
+      isFirstInDuration: false
+    };
+  }
+  set(key, points) {
+    let secDuration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    const msDuration = (secDuration >= 0 ? secDuration : this.duration) * 1000;
+    this.memoryStorage.set(this.getKey(key), points, secDuration);
+    return {
+      remainingPoints: 0,
+      msBeforeNext: msDuration === 0 ? -1 : msDuration,
+      consumedPoints: points,
+      isFirstInDuration: false
+    };
+  }
+  get(key) {
+    const res = this.memoryStorage.get(this.getKey(key));
+    if (res != null) {
+      res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+    }
+    return res;
+  }
+  delete(key) {
+    this.memoryStorage.delete(this.getKey(key));
+  }
+  _getKeySecDuration(options) {
+    if (options?.customDuration != null && options.customDuration >= 0) {
+      return options.customDuration;
+    }
+    return this.duration;
+  }
+  getKey(key) {
+    return this.keyPrefix.length > 0 ? `${this.keyPrefix}:${key}` : key;
+  }
+  parseKey(rlKey) {
+    return rlKey.substring(this.keyPrefix.length);
+  }
+}
+class MemoryStorage {
+  storage;
+  constructor() {
+    this.storage = new Map();
+  }
+  incrby(key, value, durationSec) {
+    const existing = this.storage.get(key);
+    if (existing != null) {
+      const msBeforeExpires = existing.expiresAt != null ? existing.expiresAt.getTime() - new Date().getTime() : -1;
+      if (existing.expiresAt == null || msBeforeExpires > 0) {
+        // Change value
+        existing.value += value;
+        return {
+          remainingPoints: 0,
+          msBeforeNext: msBeforeExpires,
+          consumedPoints: existing.value,
+          isFirstInDuration: false
+        };
+      }
+      return this.set(key, value, durationSec);
+    }
+    return this.set(key, value, durationSec);
+  }
+  set(key, value, durationSec) {
+    const durationMs = durationSec * 1000;
+    const existing = this.storage.get(key);
+    if (existing != null) {
+      clearTimeout(existing.timeoutId);
+    }
+    const record = {
+      value,
+      expiresAt: durationMs > 0 ? new Date(Date.now() + durationMs) : undefined
+    };
+    this.storage.set(key, record);
+    if (durationMs > 0) {
+      record.timeoutId = setTimeout(() => {
+        this.storage.delete(key);
+      }, durationMs);
+      if (record.timeoutId.unref != null) {
+        record.timeoutId.unref();
+      }
+    }
+    return {
+      remainingPoints: 0,
+      msBeforeNext: durationMs === 0 ? -1 : durationMs,
+      consumedPoints: record.value,
+      isFirstInDuration: true
+    };
+  }
+  get(key) {
+    const existing = this.storage.get(key);
+    if (existing != null) {
+      const msBeforeExpires = existing.expiresAt != null ? existing.expiresAt.getTime() - new Date().getTime() : -1;
+      return {
+        remainingPoints: 0,
+        msBeforeNext: msBeforeExpires,
+        consumedPoints: existing.value,
+        isFirstInDuration: false
+      };
+    }
+  }
+  delete(key) {
+    const record = this.storage.get(key);
+    if (record != null) {
+      if (record.timeoutId != null) {
+        clearTimeout(record.timeoutId);
+      }
+      this.storage.delete(key);
+      return true;
+    }
+    return false;
+  }
+}
+
+export { MemoryStorage, RateLimiter };

package/dist/esm/node_modules/@libp2p/utils/dist/src/repeating-task.js

@@ -1,5 +1,5 @@
-import { setMaxListeners } from '@libp2p/interface';
 import { anySignal } from '../../../../any-signal/dist/src/index.js';
+import { setMaxListeners } from '../../../interface/dist/src/events.browser.js';
 
 function repeatingTask(fn, interval, options) {
   let timeout;
@@ -10,7 +10,6 @@ function repeatingTask(fn, interval, options) {
     };
     if (options?.timeout != null) {
       const signal = anySignal([shutdownController.signal, AbortSignal.timeout(options.timeout)]);
-      setMaxListeners(Infinity, signal);
       opts.signal = signal;
     }
     Promise.resolve().then(async () => {

package/dist/esm/node_modules/@libp2p/utils/dist/src/tracked-map.js

@@ -0,0 +1,47 @@
+class TrackedMap extends Map {
+  metric;
+  constructor(init) {
+    super();
+    const {
+      name,
+      metrics
+    } = init;
+    this.metric = metrics.registerMetric(name);
+    this.updateComponentMetric();
+  }
+  set(key, value) {
+    super.set(key, value);
+    this.updateComponentMetric();
+    return this;
+  }
+  delete(key) {
+    const deleted = super.delete(key);
+    this.updateComponentMetric();
+    return deleted;
+  }
+  clear() {
+    super.clear();
+    this.updateComponentMetric();
+  }
+  updateComponentMetric() {
+    this.metric.update(this.size);
+  }
+}
+function trackedMap(config) {
+  const {
+    name,
+    metrics
+  } = config;
+  let map;
+  if (metrics != null) {
+    map = new TrackedMap({
+      name,
+      metrics
+    });
+  } else {
+    map = new Map();
+  }
+  return map;
+}
+
+export { trackedMap };

package/dist/esm/node_modules/@libp2p/webrtc/dist/src/private-to-private/initiate-connection.js

@@ -1,5 +1,4 @@
-import { InvalidParametersError } from '@libp2p/interface';
-import { peerIdFromString } from '@libp2p/peer-id';
+import { peerIdFromString } from '../../../../peer-id/dist/src/index.js';
 import { pbStream } from '../../../../../it-protobuf-stream/dist/src/index.js';
 import { CustomProgressEvent } from '../../../../../progress-events/dist/src/index.js';
 import { SIGNALING_PROTOCOL } from '../constants.js';
@@ -9,6 +8,7 @@ import { RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.browse
 import { Message } from './pb/message.js';
 import { splitAddr } from './transport.js';
 import { readCandidatesUntilConnected } from './util.js';
+import { InvalidParametersError } from '../../../../interface/dist/src/errors.js';
 
 async function initiateConnection(_ref) {
   let {

package/dist/esm/node_modules/@libp2p/webrtc/dist/src/private-to-private/listener.js

@@ -1,6 +1,6 @@
-import { TypedEventEmitter } from '@libp2p/interface';
 import { P2P } from '../../../../../@multiformats/multiaddr-matcher/dist/src/index.js';
 import { fmt, literal } from '../../../../../@multiformats/multiaddr-matcher/dist/src/utils.js';
+import { TypedEventEmitter } from '../../../../interface/dist/src/event-target.js';
 
 const Circuit = fmt(P2P.matchers[0], literal('p2p-circuit'));
 class WebRTCPeerListener extends TypedEventEmitter {

package/dist/esm/node_modules/@libp2p/webrtc/dist/src/private-to-private/signaling-stream-handler.js

@@ -1,4 +1,4 @@
-import { multiaddr } from '@multiformats/multiaddr';
+import { multiaddr } from '../../../../../@multiformats/multiaddr/dist/src/index.js';
 import { pbStream } from '../../../../../it-protobuf-stream/dist/src/index.js';
 import { SDPHandshakeFailedError } from '../error.js';
 import { RTCSessionDescription } from '../webrtc/index.browser.js';

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

@@ -1,6 +1,6 @@
-import { setMaxListeners, transportSymbol, serviceCapabilities, serviceDependencies, InvalidParametersError } from '@libp2p/interface';
-import { peerIdFromString } from '@libp2p/peer-id';
-import { multiaddr } from '@multiformats/multiaddr';
+import { serviceCapabilities, serviceDependencies } from '../../../../interface/dist/src/index.js';
+import { peerIdFromString } from '../../../../peer-id/dist/src/index.js';
+import { multiaddr } from '../../../../../@multiformats/multiaddr/dist/src/index.js';
 import { WebRTC } from '../../../../../@multiformats/multiaddr-matcher/dist/src/index.js';
 import { SIGNALING_PROTOCOL } from '../constants.js';
 import { WebRTCMultiaddrConnection } from '../maconn.js';
@@ -10,6 +10,9 @@ import { RTCPeerConnection } from '../webrtc/index.browser.js';
 import { initiateConnection } from './initiate-connection.js';
 import { WebRTCPeerListener } from './listener.js';
 import { handleIncomingStream } from './signaling-stream-handler.js';
+import { setMaxListeners } from '../../../../interface/dist/src/events.browser.js';
+import { transportSymbol } from '../../../../interface/dist/src/transport.js';
+import { InvalidParametersError } from '../../../../interface/dist/src/errors.js';
 
 class WebRTCTransport {
   components;

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

@@ -1,9 +1,9 @@
-import { InvalidMessageError, ConnectionFailedError } from '@libp2p/interface';
 import pDefer from '../../../../../p-defer/index.js';
 import { CustomProgressEvent } from '../../../../../progress-events/dist/src/index.js';
 import { isFirefox } from '../util.js';
 import { RTCIceCandidate } from '../webrtc/index.browser.js';
 import { Message } from './pb/message.js';
+import { InvalidMessageError, ConnectionFailedError } from '../../../../interface/dist/src/errors.js';
 
 const readCandidatesUntilConnected = async (pc, stream, options) => {
   try {

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

@@ -1,5 +1,5 @@
-import { TypedEventEmitter } from '@libp2p/interface';
 import { UnimplementedError } from '../error.js';
+import { TypedEventEmitter } from '../../../../interface/dist/src/event-target.js';
 
 class WebRTCDirectListener extends TypedEventEmitter {
   async listen() {

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

@@ -1,6 +1,6 @@
 import { generateKeyPair, privateKeyToCryptoKeyPair } from '../../../../crypto/dist/src/keys/index.js';
-import { TypedEventEmitter, InvalidParametersError, transportSymbol, serviceCapabilities, NotStartedError, NotFoundError } from '@libp2p/interface';
-import { peerIdFromString } from '@libp2p/peer-id';
+import { serviceCapabilities } from '../../../../interface/dist/src/index.js';
+import { peerIdFromString } from '../../../../peer-id/dist/src/index.js';
 import { WebRTCDirect } from '../../../../../@multiformats/multiaddr-matcher/dist/src/index.js';
 import { X509Certificate, X509CertificateGenerator, BasicConstraintsExtension } from '../../../../../@peculiar/x509/build/x509.es.js';
 import { Key } from '../../../../../interface-datastore/dist/src/key.js';
@@ -14,6 +14,9 @@ import { WebRTCDirectListener } from './listener.browser.js';
 import { connect } from './utils/connect.js';
 import { createDialerRTCPeerConnection } from './utils/get-rtcpeerconnection.browser.js';
 import { formatAsPem } from './utils/pem.js';
+import { InvalidParametersError, NotStartedError, NotFoundError } from '../../../../interface/dist/src/errors.js';
+import { TypedEventEmitter } from '../../../../interface/dist/src/event-target.js';
+import { transportSymbol } from '../../../../interface/dist/src/transport.js';
 
 class WebRTCDirectTransport {
   log;
@@ -149,7 +152,7 @@ class WebRTCDirectTransport {
         throw err;
       }
       this.log.trace('generating private key');
-      this.privateKey = await generateKeyPair();
+      this.privateKey = await generateKeyPair('ECDSA', 'P-256');
       if (keychain != null) {
         this.log.trace('storing private key');
         await keychain.importKey(keychainName, this.privateKey);

package/dist/esm/node_modules/@libp2p/webrtc/dist/src/private-to-public/utils/sdp.js

@@ -1,11 +1,11 @@
-import { InvalidParametersError } from '@libp2p/interface';
-import { multiaddr } from '@multiformats/multiaddr';
+import { multiaddr } from '../../../../../../@multiformats/multiaddr/dist/src/index.js';
 import { base64url } from '../../../../../../multiformats/dist/src/bases/base64.js';
 import { bases } from '../../../../../../multiformats/dist/src/basics.js';
 import { create, decode } from '../../../../../../multiformats/dist/src/hashes/digest.js';
 import { sha256 } from '../../../../../../multiformats/dist/src/hashes/sha2-browser.js';
 import { MAX_MESSAGE_SIZE, CODEC_CERTHASH } from '../../constants.js';
 import { InvalidFingerprintError, UnsupportedHashAlgorithmError } from '../../error.js';
+import { InvalidParametersError } from '../../../../../interface/dist/src/errors.js';
 
 /**
  * Get base2 | identity decoders