web-dc-api 0.0.62 → 0.0.64

package/dist/cjs/node_modules/@libp2p/mplex/dist/src/mplex.js

@@ -1,345 +0,0 @@
-'use strict';
-
-var closeSource = require('../../../utils/dist/src/close-source.js');
-var rateLimiter = require('../../../utils/dist/src/rate-limiter.js');
-var index$1 = require('../../../../it-pipe/dist/src/index.js');
-var index = require('../../../../it-pushable/dist/src/index.js');
-require('../../../../multiformats/dist/src/bases/base10.js');
-require('../../../../multiformats/dist/src/bases/base16.js');
-require('../../../../multiformats/dist/src/bases/base2.js');
-require('../../../../multiformats/dist/src/bases/base256emoji.js');
-require('../../../../multiformats/dist/src/bases/base32.js');
-require('../../../../multiformats/dist/src/bases/base36.js');
-require('../../../../multiformats/dist/src/bases/base58.js');
-require('../../../../multiformats/dist/src/bases/base64.js');
-require('../../../../multiformats/dist/src/bases/base8.js');
-require('../../../../multiformats/dist/src/bases/identity.js');
-require('../../../../multiformats/dist/src/codecs/json.js');
-require('../../../../multiformats/dist/src/hashes/sha2-browser.js');
-var toString = require('../../../../uint8arrays/dist/src/to-string.js');
-var decode = require('./decode.js');
-var encode = require('./encode.js');
-var errors$1 = require('./errors.js');
-var messageTypes = require('./message-types.js');
-var stream = require('./stream.js');
-var errors = require('../../../interface/dist/src/errors.js');
-
-const MAX_STREAMS_INBOUND_STREAMS_PER_CONNECTION = 1024;
-const MAX_STREAMS_OUTBOUND_STREAMS_PER_CONNECTION = 1024;
-const MAX_STREAM_BUFFER_SIZE = 1024 * 1024 * 4; // 4MB
-const DISCONNECT_THRESHOLD = 5;
-const CLOSE_TIMEOUT = 500;
-function printMessage(msg) {
-  const output = {
-    ...msg,
-    type: `${messageTypes.MessageTypeNames[msg.type]} (${msg.type})`
-  };
-  if (msg.type === messageTypes.MessageTypes.NEW_STREAM) {
-    output.data = toString.toString(msg.data instanceof Uint8Array ? msg.data : msg.data.subarray());
-  }
-  if (msg.type === messageTypes.MessageTypes.MESSAGE_INITIATOR || msg.type === messageTypes.MessageTypes.MESSAGE_RECEIVER) {
-    output.data = toString.toString(msg.data instanceof Uint8Array ? msg.data : msg.data.subarray(), 'base16');
-  }
-  return output;
-}
-class MplexStreamMuxer {
-  protocol = '/mplex/6.7.0';
-  sink;
-  source;
-  log;
-  _streamId;
-  _streams;
-  _init;
-  _source;
-  closeController;
-  rateLimiter;
-  closeTimeout;
-  logger;
-  constructor(components, init) {
-    init = init ?? {};
-    this.log = components.logger.forComponent('libp2p:mplex');
-    this.logger = components.logger;
-    this._streamId = 0;
-    this._streams = {
-      /**
-       * Stream to ids map
-       */
-      initiators: new Map(),
-      /**
-       * Stream to ids map
-       */
-      receivers: new Map()
-    };
-    this._init = init;
-    this.closeTimeout = init.closeTimeout ?? CLOSE_TIMEOUT;
-    /**
-     * An iterable sink
-     */
-    this.sink = this._createSink();
-    /**
-     * An iterable source
-     */
-    this._source = index.pushable({
-      objectMode: true,
-      onEnd: () => {
-        // the source has ended, we can't write any more messages to gracefully
-        // close streams so all we can do is destroy them
-        for (const stream of this._streams.initiators.values()) {
-          stream.destroy();
-        }
-        for (const stream of this._streams.receivers.values()) {
-          stream.destroy();
-        }
-      }
-    });
-    this.source = index$1.pipe(this._source, source => encode.encode(source));
-    /**
-     * Close controller
-     */
-    this.closeController = new AbortController();
-    this.rateLimiter = new rateLimiter.RateLimiter({
-      points: init.disconnectThreshold ?? DISCONNECT_THRESHOLD,
-      duration: 1
-    });
-  }
-  /**
-   * Returns a Map of streams and their ids
-   */
-  get streams() {
-    // Inbound and Outbound streams may have the same ids, so we need to make those unique
-    const streams = [];
-    for (const stream of this._streams.initiators.values()) {
-      streams.push(stream);
-    }
-    for (const stream of this._streams.receivers.values()) {
-      streams.push(stream);
-    }
-    return streams;
-  }
-  /**
-   * Initiate a new stream with the given name. If no name is
-   * provided, the id of the stream will be used.
-   */
-  newStream(name) {
-    if (this.closeController.signal.aborted) {
-      throw new errors.MuxerClosedError('Muxer already closed');
-    }
-    const id = this._streamId++;
-    name = name == null ? id.toString() : name.toString();
-    const registry = this._streams.initiators;
-    return this._newStream({
-      id,
-      name,
-      type: 'initiator',
-      registry
-    });
-  }
-  /**
-   * Close or abort all tracked streams and stop the muxer
-   */
-  async close(options) {
-    if (this.closeController.signal.aborted) {
-      return;
-    }
-    const signal = options?.signal ?? AbortSignal.timeout(this.closeTimeout);
-    try {
-      // try to gracefully close all streams
-      await Promise.all(this.streams.map(async s => s.close({
-        signal
-      })));
-      this._source.end();
-      // try to gracefully close the muxer
-      await this._source.onEmpty({
-        signal
-      });
-      this.closeController.abort();
-    } catch (err) {
-      this.abort(err);
-    }
-  }
-  abort(err) {
-    if (this.closeController.signal.aborted) {
-      return;
-    }
-    this.streams.forEach(s => {
-      s.abort(err);
-    });
-    this.closeController.abort(err);
-  }
-  /**
-   * Called whenever an inbound stream is created
-   */
-  _newReceiverStream(options) {
-    const {
-      id,
-      name
-    } = options;
-    const registry = this._streams.receivers;
-    return this._newStream({
-      id,
-      name,
-      type: 'receiver',
-      registry
-    });
-  }
-  _newStream(options) {
-    const {
-      id,
-      name,
-      type,
-      registry
-    } = options;
-    this.log('new %s stream %s', type, id);
-    if (type === 'initiator' && this._streams.initiators.size === (this._init.maxOutboundStreams ?? MAX_STREAMS_OUTBOUND_STREAMS_PER_CONNECTION)) {
-      throw new errors.TooManyOutboundProtocolStreamsError('Too many outbound streams open');
-    }
-    if (registry.has(id)) {
-      throw new Error(`${type} stream ${id} already exists!`);
-    }
-    const send = async msg => {
-      if (this.log.enabled) {
-        this.log.trace('%s stream %s send', type, id, printMessage(msg));
-      }
-      this._source.push(msg);
-    };
-    const onEnd = () => {
-      this.log('%s stream with id %s and protocol %s ended', type, id, stream$1.protocol);
-      registry.delete(id);
-      if (this._init.onStreamEnd != null) {
-        this._init.onStreamEnd(stream$1);
-      }
-    };
-    const stream$1 = stream.createStream({
-      id,
-      name,
-      send,
-      type,
-      onEnd,
-      maxMsgSize: this._init.maxMsgSize,
-      logger: this.logger
-    });
-    registry.set(id, stream$1);
-    return stream$1;
-  }
-  /**
-   * Creates a sink with an abortable source. Incoming messages will
-   * also have their size restricted. All messages will be varint decoded.
-   */
-  _createSink() {
-    const sink = async source => {
-      const abortListener = () => {
-        closeSource.closeSource(source, this.log);
-      };
-      this.closeController.signal.addEventListener('abort', abortListener);
-      try {
-        const decoder = new decode.Decoder(this._init.maxMsgSize, this._init.maxUnprocessedMessageQueueSize);
-        for await (const chunk of source) {
-          for (const msg of decoder.write(chunk)) {
-            await this._handleIncoming(msg);
-          }
-        }
-        this._source.end();
-      } catch (err) {
-        this.log('error in sink', err);
-        this._source.end(err); // End the source with an error
-      } finally {
-        this.closeController.signal.removeEventListener('abort', abortListener);
-      }
-    };
-    return sink;
-  }
-  async _handleIncoming(message) {
-    const {
-      id,
-      type
-    } = message;
-    if (this.log.enabled) {
-      this.log.trace('incoming message', printMessage(message));
-    }
-    // Create a new stream?
-    if (message.type === messageTypes.MessageTypes.NEW_STREAM) {
-      if (this._streams.receivers.size === (this._init.maxInboundStreams ?? MAX_STREAMS_INBOUND_STREAMS_PER_CONNECTION)) {
-        this.log('too many inbound streams open');
-        // not going to allow this stream, send the reset message manually
-        // instead of setting it up just to tear it down
-        this._source.push({
-          id,
-          type: messageTypes.MessageTypes.RESET_RECEIVER
-        });
-        // if we've hit our stream limit, and the remote keeps trying to open
-        // more new streams, if they are doing this very quickly maybe they
-        // are attacking us and we should close the connection
-        try {
-          await this.rateLimiter.consume('new-stream', 1);
-        } catch {
-          this.log('rate limit hit when opening too many new streams over the inbound stream limit - closing remote connection');
-          // since there's no backpressure in mplex, the only thing we can really do to protect ourselves is close the connection
-          this.abort(new Error('Too many open streams'));
-          return;
-        }
-        return;
-      }
-      const stream = this._newReceiverStream({
-        id,
-        name: toString.toString(message.data instanceof Uint8Array ? message.data : message.data.subarray())
-      });
-      if (this._init.onIncomingStream != null) {
-        this._init.onIncomingStream(stream);
-      }
-      return;
-    }
-    const list = (type & 1) === 1 ? this._streams.initiators : this._streams.receivers;
-    const stream = list.get(id);
-    if (stream == null) {
-      this.log('missing stream %s for message type %s', id, messageTypes.MessageTypeNames[type]);
-      // if the remote keeps sending us messages for streams that have been
-      // closed or were never opened they may be attacking us so if they do
-      // this very quickly all we can do is close the connection
-      try {
-        await this.rateLimiter.consume('missing-stream', 1);
-      } catch {
-        this.log('rate limit hit when receiving messages for streams that do not exist - closing remote connection');
-        // since there's no backpressure in mplex, the only thing we can really do to protect ourselves is close the connection
-        this.abort(new Error('Too many messages for missing streams'));
-        return;
-      }
-      return;
-    }
-    const maxBufferSize = this._init.maxStreamBufferSize ?? MAX_STREAM_BUFFER_SIZE;
-    try {
-      switch (type) {
-        case messageTypes.MessageTypes.MESSAGE_INITIATOR:
-        case messageTypes.MessageTypes.MESSAGE_RECEIVER:
-          if (stream.sourceReadableLength() > maxBufferSize) {
-            // Stream buffer has got too large, reset the stream
-            this._source.push({
-              id: message.id,
-              type: type === messageTypes.MessageTypes.MESSAGE_INITIATOR ? messageTypes.MessageTypes.RESET_RECEIVER : messageTypes.MessageTypes.RESET_INITIATOR
-            });
-            // Inform the stream consumer they are not fast enough
-            throw new errors$1.StreamInputBufferError('Input buffer full - increase Mplex maxBufferSize to accommodate slow consumers');
-          }
-          // We got data from the remote, push it into our local stream
-          stream.sourcePush(message.data);
-          break;
-        case messageTypes.MessageTypes.CLOSE_INITIATOR:
-        case messageTypes.MessageTypes.CLOSE_RECEIVER:
-          // The remote has stopped writing, so we can stop reading
-          stream.remoteCloseWrite();
-          break;
-        case messageTypes.MessageTypes.RESET_INITIATOR:
-        case messageTypes.MessageTypes.RESET_RECEIVER:
-          // The remote has errored, stop reading and writing to the stream immediately
-          stream.reset();
-          break;
-        default:
-          this.log('unknown message type %s', type);
-      }
-    } catch (err) {
-      this.log.error('error while processing message', err);
-      stream.abort(err);
-    }
-  }
-}
-
-exports.MplexStreamMuxer = MplexStreamMuxer;

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

@@ -1,80 +0,0 @@
-'use strict';
-
-var abstractStream = require('../../../utils/dist/src/abstract-stream.js');
-var index = require('../../../../uint8arraylist/dist/src/index.js');
-var fromString = require('../../../../uint8arrays/dist/src/from-string.js');
-var decode = require('./decode.js');
-var messageTypes = require('./message-types.js');
-
-class MplexStream extends abstractStream.AbstractStream {
-  name;
-  streamId;
-  send;
-  types;
-  maxDataSize;
-  constructor(init) {
-    super(init);
-    this.types = init.direction === 'outbound' ? messageTypes.InitiatorMessageTypes : messageTypes.ReceiverMessageTypes;
-    this.send = init.send;
-    this.name = init.name;
-    this.streamId = init.streamId;
-    this.maxDataSize = init.maxDataSize;
-  }
-  async sendNewStream() {
-    await this.send({
-      id: this.streamId,
-      type: messageTypes.InitiatorMessageTypes.NEW_STREAM,
-      data: new index.Uint8ArrayList(fromString.fromString(this.name))
-    });
-  }
-  async sendData(data) {
-    data = data.sublist();
-    while (data.byteLength > 0) {
-      const toSend = Math.min(data.byteLength, this.maxDataSize);
-      await this.send({
-        id: this.streamId,
-        type: this.types.MESSAGE,
-        data: data.sublist(0, toSend)
-      });
-      data.consume(toSend);
-    }
-  }
-  async sendReset() {
-    await this.send({
-      id: this.streamId,
-      type: this.types.RESET
-    });
-  }
-  async sendCloseWrite() {
-    await this.send({
-      id: this.streamId,
-      type: this.types.CLOSE
-    });
-  }
-  async sendCloseRead() {
-    // mplex does not support close read, only close write
-  }
-}
-function createStream(options) {
-  const {
-    id,
-    name,
-    send,
-    onEnd,
-    type = 'initiator',
-    maxMsgSize = decode.MAX_MSG_SIZE
-  } = options;
-  return new MplexStream({
-    id: type === 'initiator' ? `i${id}` : `r${id}`,
-    streamId: id,
-    name: `${name ?? id}`,
-    direction: type === 'initiator' ? 'outbound' : 'inbound',
-    maxDataSize: maxMsgSize,
-    onEnd,
-    send,
-    log: options.logger.forComponent(`libp2p:mplex:stream:${type}:${id}`)
-  });
-}
-
-exports.MplexStream = MplexStream;
-exports.createStream = createStream;

package/dist/cjs/node_modules/@libp2p/multistream-select/dist/src/constants.js

@@ -1,9 +0,0 @@
-'use strict';
-
-const PROTOCOL_ID = '/multistream/1.0.0';
-// Conforming to go-libp2p
-// See https://github.com/multiformats/go-multistream/blob/master/multistream.go#L297
-const MAX_PROTOCOL_LENGTH = 1024;
-
-exports.MAX_PROTOCOL_LENGTH = MAX_PROTOCOL_LENGTH;
-exports.PROTOCOL_ID = PROTOCOL_ID;

package/dist/cjs/node_modules/@libp2p/multistream-select/dist/src/handle.js

@@ -1,98 +0,0 @@
-'use strict';
-
-var encode = require('../../../../it-length-prefixed/dist/src/encode.js');
-require('../../../../it-length-prefixed/dist/src/decode.js');
-var index = require('../../../../it-length-prefixed-stream/dist/src/index.js');
-var index$1 = require('../../../../uint8arraylist/dist/src/index.js');
-var fromString = require('../../../../uint8arrays/dist/src/from-string.js');
-var constants = require('./constants.js');
-var multistream = require('./multistream.js');
-
-/**
- * Handle multistream protocol selections for the given list of protocols.
- *
- * Note that after a protocol is handled `listener` can no longer be used.
- *
- * @param stream - A duplex iterable stream to listen on
- * @param protocols - A list of protocols (or single protocol) that this listener is able to speak.
- * @param options - an options object containing an AbortSignal and an optional boolean `writeBytes` - if this is true, `Uint8Array`s will be written into `duplex`, otherwise `Uint8ArrayList`s will
- * @returns A stream for the selected protocol and the protocol that was selected from the list of protocols provided to `select`
- * @example
- *
- * ```TypeScript
- * import { pipe } from 'it-pipe'
- * import * as mss from '@libp2p/multistream-select'
- * import { Mplex } from '@libp2p/mplex'
- *
- * const muxer = new Mplex({
- *   async onStream (muxedStream) {
- *   // mss.handle(handledProtocols)
- *   // Returns selected stream and protocol
- *   const { stream, protocol } = await mss.handle(muxedStream, [
- *     '/ipfs-dht/1.0.0',
- *     '/ipfs-bitswap/1.0.0'
- *   ])
- *
- *   // Typically here we'd call the handler function that was registered in
- *   // libp2p for the given protocol:
- *   // e.g. handlers[protocol].handler(stream)
- *   //
- *   // If protocol was /ipfs-dht/1.0.0 it might do something like this:
- *   // try {
- *   //   await pipe(
- *   //     dhtStream,
- *   //     source => (async function * () {
- *   //       for await (const chunk of source)
- *   //         // Incoming DHT data -> process and yield to respond
- *   //     })(),
- *   //     dhtStream
- *   //   )
- *   // } catch (err) {
- *   //   // Error in stream
- *   // }
- *   }
- * })
- * ```
- */
-async function handle(stream, protocols, options) {
-  protocols = Array.isArray(protocols) ? protocols : [protocols];
-  options.log.trace('handle: available protocols %s', protocols);
-  const lp = index.lpStream(stream, {
-    ...options,
-    maxDataLength: constants.MAX_PROTOCOL_LENGTH,
-    maxLengthLength: 2 // 2 bytes is enough to length-prefix MAX_PROTOCOL_LENGTH
-  });
-  while (true) {
-    options.log.trace('handle: reading incoming string');
-    const protocol = await multistream.readString(lp, options);
-    options.log.trace('handle: read "%s"', protocol);
-    if (protocol === constants.PROTOCOL_ID) {
-      options.log.trace('handle: respond with "%s" for "%s"', constants.PROTOCOL_ID, protocol);
-      await multistream.write(lp, fromString.fromString(`${constants.PROTOCOL_ID}\n`), options);
-      options.log.trace('handle: responded with "%s" for "%s"', constants.PROTOCOL_ID, protocol);
-      continue;
-    }
-    if (protocols.includes(protocol)) {
-      options.log.trace('handle: respond with "%s" for "%s"', protocol, protocol);
-      await multistream.write(lp, fromString.fromString(`${protocol}\n`), options);
-      options.log.trace('handle: responded with "%s" for "%s"', protocol, protocol);
-      return {
-        stream: lp.unwrap(),
-        protocol
-      };
-    }
-    if (protocol === 'ls') {
-      // <varint-msg-len><varint-proto-name-len><proto-name>\n<varint-proto-name-len><proto-name>\n\n
-      const protos = new index$1.Uint8ArrayList(...protocols.map(p => encode.encode.single(fromString.fromString(`${p}\n`))), fromString.fromString('\n'));
-      options.log.trace('handle: respond with "%s" for %s', protocols, protocol);
-      await multistream.write(lp, protos, options);
-      options.log.trace('handle: responded with "%s" for %s', protocols, protocol);
-      continue;
-    }
-    options.log.trace('handle: respond with "na" for "%s"', protocol);
-    await multistream.write(lp, fromString.fromString('na\n'), options);
-    options.log('handle: responded with "na" for "%s"', protocol);
-  }
-}
-
-exports.handle = handle;

package/dist/cjs/node_modules/@libp2p/multistream-select/dist/src/multistream.js

@@ -1,42 +0,0 @@
-'use strict';
-
-var fromString = require('../../../../uint8arrays/dist/src/from-string.js');
-var toString = require('../../../../uint8arrays/dist/src/to-string.js');
-var errors = require('../../../interface/dist/src/errors.js');
-
-const NewLine = fromString.fromString('\n');
-/**
- * `write` encodes and writes a single buffer
- */
-async function write(writer, buffer, options) {
-  await writer.write(buffer, options);
-}
-/**
- * `writeAll` behaves like `write`, except it encodes an array of items as a single write
- */
-async function writeAll(writer, buffers, options) {
-  await writer.writeV(buffers, options);
-}
-/**
- * Read a length-prefixed buffer from the passed stream, stripping the final newline character
- */
-async function read(reader, options) {
-  const buf = await reader.read(options);
-  if (buf.byteLength === 0 || buf.get(buf.byteLength - 1) !== NewLine[0]) {
-    options.log.error('Invalid mss message - missing newline', buf);
-    throw new errors.InvalidMessageError('Missing newline');
-  }
-  return buf.sublist(0, -1); // Remove newline
-}
-/**
- * Read a length-prefixed string from the passed stream, stripping the final newline character
- */
-async function readString(reader, options) {
-  const buf = await read(reader, options);
-  return toString.toString(buf.subarray());
-}
-
-exports.read = read;
-exports.readString = readString;
-exports.write = write;
-exports.writeAll = writeAll;