web-dc-api 0.0.58 → 0.0.60

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

@@ -0,0 +1,160 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var multiaddr = require('@multiformats/multiaddr');
+var base64 = require('../../../../../../multiformats/dist/src/bases/base64.js');
+var basics = require('../../../../../../multiformats/dist/src/basics.js');
+var digest = require('../../../../../../multiformats/dist/src/hashes/digest.js');
+var sha2Browser = require('../../../../../../multiformats/dist/src/hashes/sha2-browser.js');
+var constants = require('../../constants.js');
+var error = require('../../error.js');
+
+/**
+ * Get base2 | identity decoders
+ */
+// @ts-expect-error - Not easy to combine these types.
+const multibaseDecoder = Object.values(basics.bases).map(b => b.decoder).reduce((d, b) => d.or(b));
+const fingerprintRegex = /^a=fingerprint:(?:\w+-[0-9]+)\s(?<fingerprint>(:?[0-9a-fA-F]{2})+)$/m;
+function getFingerprintFromSdp(sdp) {
+  if (sdp == null) {
+    return undefined;
+  }
+  const searchResult = sdp.match(fingerprintRegex);
+  return searchResult?.groups?.fingerprint;
+}
+// Extract the certhash from a multiaddr
+function certhash(ma) {
+  const tups = ma.stringTuples();
+  const certhash = tups.filter(tup => tup[0] === constants.CODEC_CERTHASH).map(tup => tup[1])[0];
+  if (certhash === undefined || certhash === '') {
+    throw new _interface.InvalidParametersError(`Couldn't find a certhash component of multiaddr: ${ma.toString()}`);
+  }
+  return certhash;
+}
+/**
+ * Convert a certhash into a multihash
+ */
+function decodeCerthash(certhash) {
+  return digest.decode(multibaseDecoder.decode(certhash));
+}
+/**
+ * Extract the fingerprint from a multiaddr
+ */
+function ma2Fingerprint(ma) {
+  const multihashDecoded = decodeCerthash(certhash(ma));
+  const prefix = toSupportedHashFunction(multihashDecoded.code);
+  const fingerprint = multihashDecoded.digest.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');
+  const sdp = fingerprint.match(/.{1,2}/g);
+  if (sdp == null) {
+    throw new error.InvalidFingerprintError(fingerprint, ma.toString());
+  }
+  return `${prefix} ${sdp.join(':').toUpperCase()}`;
+}
+function fingerprint2Ma(fingerprint) {
+  const output = fingerprint.split(':').map(str => parseInt(str, 16));
+  const encoded = Uint8Array.from(output);
+  const digest$1 = digest.create(sha2Browser.sha256.code, encoded);
+  return multiaddr.multiaddr(`/certhash/${base64.base64url.encode(digest$1.bytes)}`);
+}
+/**
+ * Normalize the hash name from a given multihash has name
+ */
+function toSupportedHashFunction(code) {
+  switch (code) {
+    case 0x11:
+      return 'sha-1';
+    case 0x12:
+      return 'sha-256';
+    case 0x13:
+      return 'sha-512';
+    default:
+      throw new error.UnsupportedHashAlgorithmError(code);
+  }
+}
+/**
+ * Create an answer SDP message from a multiaddr - the server always operates in
+ * ice-lite mode and DTLS active mode.
+ */
+function serverAnswerFromMultiaddr(ma, ufrag) {
+  const {
+    host,
+    port,
+    family
+  } = ma.toOptions();
+  const fingerprint = ma2Fingerprint(ma);
+  const sdp = `v=0
+o=- 0 0 IN IP${family} ${host}
+s=-
+t=0 0
+a=ice-lite
+m=application ${port} UDP/DTLS/SCTP webrtc-datachannel
+c=IN IP${family} ${host}
+a=mid:0
+a=ice-options:ice2
+a=ice-ufrag:${ufrag}
+a=ice-pwd:${ufrag}
+a=fingerprint:${fingerprint}
+a=setup:passive
+a=sctp-port:5000
+a=max-message-size:${constants.MAX_MESSAGE_SIZE}
+a=candidate:1467250027 1 UDP 1467250027 ${host} ${port} typ host
+a=end-of-candidates
+`;
+  return {
+    type: 'answer',
+    sdp
+  };
+}
+/**
+ * Create an offer SDP message from a multiaddr
+ */
+function clientOfferFromMultiAddr(ma, ufrag) {
+  const {
+    host,
+    port,
+    family
+  } = ma.toOptions();
+  const sdp = `v=0
+o=- 0 0 IN IP${family} ${host}
+s=-
+c=IN IP${family} ${host}
+t=0 0
+a=ice-options:ice2,trickle
+m=application ${port} UDP/DTLS/SCTP webrtc-datachannel
+a=mid:0
+a=setup:active
+a=ice-ufrag:${ufrag}
+a=ice-pwd:${ufrag}
+a=fingerprint:sha-256 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00
+a=sctp-port:5000
+a=max-message-size:${constants.MAX_MESSAGE_SIZE}
+a=candidate:1467250027 1 UDP 1467250027 ${host} ${port} typ host
+a=end-of-candidates
+`;
+  return {
+    type: 'offer',
+    sdp
+  };
+}
+/**
+ * Replace (munge) the ufrag and password values in a SDP
+ */
+function munge(desc, ufrag) {
+  if (desc.sdp === undefined) {
+    throw new _interface.InvalidParametersError("Can't munge a missing SDP");
+  }
+  const lineBreak = desc.sdp.includes('\r\n') ? '\r\n' : '\n';
+  desc.sdp = desc.sdp.replace(/\na=ice-ufrag:[^\n]*\n/, '\na=ice-ufrag:' + ufrag + lineBreak).replace(/\na=ice-pwd:[^\n]*\n/, '\na=ice-pwd:' + ufrag + lineBreak);
+  return desc;
+}
+
+exports.certhash = certhash;
+exports.clientOfferFromMultiAddr = clientOfferFromMultiAddr;
+exports.decodeCerthash = decodeCerthash;
+exports.fingerprint2Ma = fingerprint2Ma;
+exports.getFingerprintFromSdp = getFingerprintFromSdp;
+exports.ma2Fingerprint = ma2Fingerprint;
+exports.multibaseDecoder = multibaseDecoder;
+exports.munge = munge;
+exports.serverAnswerFromMultiaddr = serverAnswerFromMultiaddr;
+exports.toSupportedHashFunction = toSupportedHashFunction;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/stream.js

@@ -0,0 +1,308 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var abstractStream = require('../../../utils/dist/src/abstract-stream.js');
+var index$4 = require('../../../../any-signal/dist/src/index.js');
+var encode = require('../../../../it-length-prefixed/dist/src/encode.js');
+var decode = require('../../../../it-length-prefixed/dist/src/decode.js');
+var index$1 = require('../../../../it-pushable/dist/src/index.js');
+var index$2 = require('../../../../p-defer/index.js');
+var index = require('../../../../p-timeout/index.js');
+var index$5 = require('../../../../race-event/dist/src/index.js');
+var index$6 = require('../../../../race-signal/dist/src/index.js');
+var index$3 = require('../../../../uint8arraylist/dist/src/index.js');
+var constants = require('./constants.js');
+var message = require('./private-to-public/pb/message.js');
+
+class WebRTCStream extends abstractStream.AbstractStream {
+  /**
+   * The data channel used to send and receive data
+   */
+  channel;
+  /**
+   * push data from the underlying datachannel to the length prefix decoder
+   * and then the protobuf decoder.
+   */
+  incomingData;
+  maxBufferedAmount;
+  bufferedAmountLowEventTimeout;
+  /**
+   * The maximum size of a message in bytes
+   */
+  maxMessageSize;
+  /**
+   * When this promise is resolved, the remote has sent us a FIN flag
+   */
+  receiveFinAck;
+  finAckTimeout;
+  openTimeout;
+  closeController;
+  constructor(init) {
+    // override onEnd to send/receive FIN_ACK before closing the stream
+    const originalOnEnd = init.onEnd;
+    init.onEnd = err => {
+      this.log.trace('readable and writeable ends closed with status "%s"', this.status);
+      void Promise.resolve(async () => {
+        if (this.timeline.abort != null || this.timeline.reset !== null) {
+          return;
+        }
+        // wait for FIN_ACK if we haven't received it already
+        try {
+          await index.default(this.receiveFinAck.promise, {
+            milliseconds: this.finAckTimeout
+          });
+        } catch (err) {
+          this.log.error('error receiving FIN_ACK', err);
+        }
+      }).then(() => {
+        // stop processing incoming messages
+        this.incomingData.end();
+        // final cleanup
+        originalOnEnd?.(err);
+      }).catch(err => {
+        this.log.error('error ending stream', err);
+      }).finally(() => {
+        this.channel.close();
+      });
+    };
+    super(init);
+    this.channel = init.channel;
+    this.channel.binaryType = 'arraybuffer';
+    this.incomingData = index$1.pushable();
+    this.bufferedAmountLowEventTimeout = init.bufferedAmountLowEventTimeout ?? constants.BUFFERED_AMOUNT_LOW_TIMEOUT;
+    this.maxBufferedAmount = init.maxBufferedAmount ?? constants.MAX_BUFFERED_AMOUNT;
+    this.maxMessageSize = (init.maxMessageSize ?? constants.MAX_MESSAGE_SIZE) - constants.PROTOBUF_OVERHEAD;
+    this.receiveFinAck = index$2.default();
+    this.finAckTimeout = init.closeTimeout ?? constants.FIN_ACK_TIMEOUT;
+    this.openTimeout = init.openTimeout ?? constants.OPEN_TIMEOUT;
+    this.closeController = new AbortController();
+    // set up initial state
+    switch (this.channel.readyState) {
+      case 'open':
+        this.timeline.open = new Date().getTime();
+        break;
+      case 'closed':
+      case 'closing':
+        if (this.timeline.close === undefined || this.timeline.close === 0) {
+          this.timeline.close = Date.now();
+        }
+        break;
+      case 'connecting':
+        // noop
+        break;
+      default:
+        this.log.error('unknown datachannel state %s', this.channel.readyState);
+        throw new _interface.StreamStateError('Unknown datachannel state');
+    }
+    // handle RTCDataChannel events
+    this.channel.onopen = _evt => {
+      this.timeline.open = new Date().getTime();
+    };
+    this.channel.onclose = _evt => {
+      this.log.trace('received onclose event');
+      // stop any in-progress writes
+      this.closeController.abort();
+      // if the channel has closed we'll never receive a FIN_ACK so resolve the
+      // promise so we don't try to wait later
+      this.receiveFinAck.resolve();
+      void this.close().catch(err => {
+        this.log.error('error closing stream after channel closed', err);
+      });
+    };
+    this.channel.onerror = evt => {
+      this.log.trace('received onerror event');
+      // stop any in-progress writes
+      this.closeController.abort();
+      const err = evt.error;
+      this.abort(err);
+    };
+    this.channel.onmessage = async event => {
+      const {
+        data
+      } = event;
+      if (data === null || data.byteLength === 0) {
+        return;
+      }
+      this.incomingData.push(new Uint8Array(data, 0, data.byteLength));
+    };
+    const self = this;
+    // pipe framed protobuf messages through a length prefixed decoder, and
+    // surface data from the `Message.message` field through a source.
+    Promise.resolve().then(async () => {
+      for await (const buf of decode.decode(this.incomingData)) {
+        const message = self.processIncomingProtobuf(buf);
+        if (message != null) {
+          self.sourcePush(new index$3.Uint8ArrayList(message));
+        }
+      }
+    }).catch(err => {
+      this.log.error('error processing incoming data channel messages', err);
+    });
+  }
+  sendNewStream() {
+    // opening new streams is handled by WebRTC so this is a noop
+  }
+  async _sendMessage(data) {
+    let checkBuffer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    if (this.channel.readyState === 'closed' || this.channel.readyState === 'closing') {
+      throw new _interface.StreamStateError(`Invalid datachannel state - ${this.channel.readyState}`);
+    }
+    if (this.channel.readyState !== 'open') {
+      const timeout = AbortSignal.timeout(this.openTimeout);
+      const signal = index$4.anySignal([this.closeController.signal, timeout]);
+      try {
+        this.log('channel state is "%s" and not "open", waiting for "open" event before sending data', this.channel.readyState);
+        await index$5.raceEvent(this.channel, 'open', signal);
+      } finally {
+        signal.clear();
+      }
+      this.log('channel state is now "%s", sending data', this.channel.readyState);
+    }
+    if (checkBuffer && this.channel.bufferedAmount > this.maxBufferedAmount) {
+      const timeout = AbortSignal.timeout(this.bufferedAmountLowEventTimeout);
+      const signal = index$4.anySignal([this.closeController.signal, timeout]);
+      try {
+        this.log('channel buffer is %d, wait for "bufferedamountlow" event', this.channel.bufferedAmount);
+        await index$5.raceEvent(this.channel, 'bufferedamountlow', signal);
+      } catch (err) {
+        if (timeout.aborted) {
+          throw new _interface.TimeoutError(`Timed out waiting for DataChannel buffer to clear after ${this.bufferedAmountLowEventTimeout}ms`);
+        }
+        throw err;
+      } finally {
+        signal.clear();
+      }
+    }
+    try {
+      this.log.trace('sending message, channel state "%s"', this.channel.readyState);
+      // send message without copying data
+      this.channel.send(data.subarray());
+    } catch (err) {
+      this.log.error('error while sending message', err);
+    }
+  }
+  async sendData(data) {
+    const bytesTotal = data.byteLength;
+    // sending messages is an async operation so use a copy of the list as it
+    // may be changed beneath us
+    data = data.sublist();
+    while (data.byteLength > 0) {
+      const toSend = Math.min(data.byteLength, this.maxMessageSize);
+      const buf = data.subarray(0, toSend);
+      const messageBuf = message.Message.encode({
+        message: buf
+      });
+      const sendBuf = encode.encode.single(messageBuf);
+      this.log.trace('sending %d/%d bytes on channel', buf.byteLength, bytesTotal);
+      await this._sendMessage(sendBuf);
+      data.consume(toSend);
+    }
+    this.log.trace('finished sending data, channel state "%s"', this.channel.readyState);
+  }
+  async sendReset() {
+    try {
+      await this._sendFlag(message.Message.Flag.RESET);
+    } catch (err) {
+      this.log.error('failed to send reset - %e', err);
+    } finally {
+      this.channel.close();
+    }
+  }
+  async sendCloseWrite(options) {
+    if (this.channel.readyState !== 'open') {
+      this.receiveFinAck.resolve();
+      return;
+    }
+    const sent = await this._sendFlag(message.Message.Flag.FIN);
+    if (sent) {
+      this.log.trace('awaiting FIN_ACK');
+      try {
+        await index$6.raceSignal(this.receiveFinAck.promise, options?.signal, {
+          errorMessage: 'sending close-write was aborted before FIN_ACK was received',
+          errorName: 'FinAckNotReceivedError'
+        });
+      } catch (err) {
+        this.log.error('failed to await FIN_ACK', err);
+      }
+    } else {
+      this.log.trace('sending FIN failed, not awaiting FIN_ACK');
+    }
+    // if we've attempted to receive a FIN_ACK, do not try again
+    this.receiveFinAck.resolve();
+  }
+  async sendCloseRead() {
+    if (this.channel.readyState !== 'open') {
+      return;
+    }
+    await this._sendFlag(message.Message.Flag.STOP_SENDING);
+  }
+  /**
+   * Handle incoming
+   */
+  processIncomingProtobuf(buffer) {
+    const message$1 = message.Message.decode(buffer);
+    if (message$1.flag !== undefined) {
+      this.log.trace('incoming flag %s, write status "%s", read status "%s"', message$1.flag, this.writeStatus, this.readStatus);
+      if (message$1.flag === message.Message.Flag.FIN) {
+        // We should expect no more data from the remote, stop reading
+        this.remoteCloseWrite();
+        this.log.trace('sending FIN_ACK');
+        void this._sendFlag(message.Message.Flag.FIN_ACK).catch(err => {
+          this.log.error('error sending FIN_ACK immediately', err);
+        });
+      }
+      if (message$1.flag === message.Message.Flag.RESET) {
+        // Stop reading and writing to the stream immediately
+        this.reset();
+      }
+      if (message$1.flag === message.Message.Flag.STOP_SENDING) {
+        // The remote has stopped reading
+        this.remoteCloseRead();
+      }
+      if (message$1.flag === message.Message.Flag.FIN_ACK) {
+        this.log.trace('received FIN_ACK');
+        this.receiveFinAck.resolve();
+      }
+    }
+    // ignore data messages if we've closed the readable end already
+    if (this.readStatus === 'ready') {
+      return message$1.message;
+    }
+  }
+  async _sendFlag(flag) {
+    if (this.channel.readyState !== 'open') {
+      // flags can be sent while we or the remote are closing the datachannel so
+      // if the channel isn't open, don't try to send it but return false to let
+      // the caller know and act if they need to
+      this.log.trace('not sending flag %s because channel is "%s" and not "open"', flag.toString(), this.channel.readyState);
+      return false;
+    }
+    this.log.trace('sending flag %s', flag.toString());
+    const messageBuf = message.Message.encode({
+      flag
+    });
+    const prefixedBuf = encode.encode.single(messageBuf);
+    try {
+      await this._sendMessage(prefixedBuf, false);
+      return true;
+    } catch (err) {
+      this.log.error('could not send flag %s - %e', flag.toString(), err);
+    }
+    return false;
+  }
+}
+function createStream(options) {
+  const {
+    channel,
+    direction,
+    handshake
+  } = options;
+  return new WebRTCStream({
+    id: `${channel.id}`,
+    log: options.logger.forComponent(`libp2p:webrtc:stream:${handshake === true ? 'handshake' : direction}:${channel.id}`),
+    ...options
+  });
+}
+
+exports.WebRTCStream = WebRTCStream;
+exports.createStream = createStream;

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

@@ -0,0 +1,72 @@
+'use strict';
+
+var index = require('../../../../detect-browser/es/index.js');
+var index$1 = require('../../../../p-defer/index.js');
+var index$2 = require('../../../../p-timeout/index.js');
+var constants = require('./constants.js');
+
+const browser = index.detect();
+const isFirefox = browser != null && browser.name === 'firefox';
+const nopSource = async function* nop() {};
+const nopSink = async _ => {};
+function drainAndClose(channel, direction) {
+  let drainTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : constants.DATA_CHANNEL_DRAIN_TIMEOUT;
+  let options = arguments.length > 3 ? arguments[3] : undefined;
+  if (channel.readyState !== 'open') {
+    return;
+  }
+  void Promise.resolve().then(async () => {
+    // wait for bufferedAmount to become zero
+    if (channel.bufferedAmount > 0) {
+      options.log('%s drain channel with %d buffered bytes', direction, channel.bufferedAmount);
+      const deferred = index$1.default();
+      let drained = false;
+      channel.bufferedAmountLowThreshold = 0;
+      const closeListener = () => {
+        if (!drained) {
+          options.log('%s drain channel closed before drain', direction);
+          deferred.resolve();
+        }
+      };
+      channel.addEventListener('close', closeListener, {
+        once: true
+      });
+      channel.addEventListener('bufferedamountlow', () => {
+        drained = true;
+        channel.removeEventListener('close', closeListener);
+        deferred.resolve();
+      });
+      await index$2.default(deferred.promise, {
+        milliseconds: drainTimeout
+      });
+    }
+  }).then(async () => {
+    // only close if the channel is still open
+    if (channel.readyState === 'open') {
+      channel.close();
+    }
+  }).catch(err => {
+    options.log.error('error closing outbound stream', err);
+  });
+}
+async function getRtcConfiguration(config) {
+  config = config ?? {};
+  if (typeof config === 'function') {
+    config = await config();
+  }
+  config.iceServers = config.iceServers ?? constants.DEFAULT_ICE_SERVERS.map(url => ({
+    urls: [url]
+  }));
+  return config;
+}
+const genUfrag = function () {
+  let len = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 32;
+  return constants.UFRAG_PREFIX + [...Array(len)].map(() => constants.UFRAG_ALPHABET.at(Math.floor(Math.random() * constants.UFRAG_ALPHABET.length))).join('');
+};
+
+exports.drainAndClose = drainAndClose;
+exports.genUfrag = genUfrag;
+exports.getRtcConfiguration = getRtcConfiguration;
+exports.isFirefox = isFirefox;
+exports.nopSink = nopSink;
+exports.nopSource = nopSource;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/webrtc/index.browser.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const RTCPeerConnection = globalThis.RTCPeerConnection;
+const RTCSessionDescription = globalThis.RTCSessionDescription;
+const RTCIceCandidate = globalThis.RTCIceCandidate;
+
+exports.RTCIceCandidate = RTCIceCandidate;
+exports.RTCPeerConnection = RTCPeerConnection;
+exports.RTCSessionDescription = RTCSessionDescription;