web-dc-api 0.0.61 → 0.0.62

package/dist/cjs/node_modules/@chainsafe/libp2p-yamux/dist/src/muxer.js

@@ -1,16 +1,18 @@
 'use strict';
 
-var _interface = require('@libp2p/interface');
-var index$2 = require('../../../../get-iterator/dist/src/index.js');
-var index = require('../../../../it-pushable/dist/src/index.js');
-var index$1 = require('../../../../uint8arraylist/dist/src/index.js');
+var index = require('../../../../@libp2p/interface/dist/src/index.js');
+var index$3 = require('../../../../get-iterator/dist/src/index.js');
+var index$1 = require('../../../../it-pushable/dist/src/index.js');
+var index$2 = require('../../../../uint8arraylist/dist/src/index.js');
 var config = require('./config.js');
 var constants = require('./constants.js');
 var decode = require('./decode.js');
 var encode = require('./encode.js');
-var errors = require('./errors.js');
+var errors$1 = require('./errors.js');
 var frame = require('./frame.js');
 var stream = require('./stream.js');
+var errors = require('../../../../@libp2p/interface/dist/src/errors.js');
+var events_browser = require('../../../../@libp2p/interface/dist/src/events.browser.js');
 
 const YAMUX_PROTOCOL_ID = '/yamux/1.0.0';
 const CLOSE_TIMEOUT = 500;
@@ -24,7 +26,7 @@ class Yamux {
     this._init = init;
   }
   [Symbol.toStringTag] = '@chainsafe/libp2p-yamux';
-  [_interface.serviceCapabilities] = ['@libp2p/stream-multiplexing'];
+  [index.serviceCapabilities] = ['@libp2p/stream-multiplexing'];
   createStreamMuxer(init) {
     return new YamuxMuxer(this._components, {
       ...this._init,
@@ -71,11 +73,11 @@ class YamuxMuxer {
     this.log = this.logger.forComponent('libp2p:yamux');
     config.verifyConfig(this.config);
     this.closeController = new AbortController();
-    _interface.setMaxListeners(Infinity, this.closeController.signal);
+    events_browser.setMaxListeners(Infinity, this.closeController.signal);
     this.onIncomingStream = init.onIncomingStream;
     this.onStreamEnd = init.onStreamEnd;
     this._streams = new Map();
-    this.source = index.pushable({
+    this.source = index$1.pushable({
       onEnd: () => {
         this.log?.trace('muxer source ended');
         this._streams.forEach(stream => {
@@ -85,7 +87,7 @@ class YamuxMuxer {
     });
     this.sink = async source => {
       const shutDownListener = () => {
-        const iterator = index$2.getIterator(source);
+        const iterator = index$3.getIterator(source);
         if (iterator.return != null) {
           const res = iterator.return();
           if (isPromise(res)) {
@@ -145,16 +147,16 @@ class YamuxMuxer {
   }
   newStream(name) {
     if (this.remoteGoAway !== undefined) {
-      throw new _interface.MuxerClosedError('Muxer closed remotely');
+      throw new errors.MuxerClosedError('Muxer closed remotely');
     }
     if (this.localGoAway !== undefined) {
-      throw new _interface.MuxerClosedError('Muxer closed locally');
+      throw new errors.MuxerClosedError('Muxer closed locally');
     }
     const id = this.nextStreamID;
     this.nextStreamID += 2;
     // check against our configured maximum number of outbound streams
     if (this.numOutboundStreams >= this.config.maxOutboundStreams) {
-      throw new _interface.TooManyOutboundProtocolStreamsError('max outbound streams exceeded');
+      throw new errors.TooManyOutboundProtocolStreamsError('max outbound streams exceeded');
     }
     this.log?.trace('new outgoing stream id=%s', id);
     const stream$1 = this._newStream(id, name, stream.StreamState.Init, 'outbound');
@@ -174,10 +176,10 @@ class YamuxMuxer {
    */
   async ping() {
     if (this.remoteGoAway !== undefined) {
-      throw new _interface.MuxerClosedError('Muxer closed remotely');
+      throw new errors.MuxerClosedError('Muxer closed remotely');
     }
     if (this.localGoAway !== undefined) {
-      throw new _interface.MuxerClosedError('Muxer closed locally');
+      throw new errors.MuxerClosedError('Muxer closed locally');
     }
     // An active ping does not yet exist, handle the process here
     if (this.activePing === undefined) {
@@ -188,7 +190,7 @@ class YamuxMuxer {
         // this promise awaits resolution or the close controller aborting
         promise: new Promise((resolve, reject) => {
           const closed = () => {
-            reject(new _interface.MuxerClosedError('Muxer closed locally'));
+            reject(new errors.MuxerClosedError('Muxer closed locally'));
           };
           this.closeController.signal.addEventListener('abort', closed, {
             once: true
@@ -242,7 +244,6 @@ class YamuxMuxer {
     this.log?.trace('muxer close reason=%s', reason);
     if (options.signal == null) {
       const signal = AbortSignal.timeout(CLOSE_TIMEOUT);
-      _interface.setMaxListeners(Infinity, signal);
       options = {
         ...options,
         signal
@@ -288,7 +289,7 @@ class YamuxMuxer {
   /** Create a new stream */
   _newStream(id, name, state, direction) {
     if (this._streams.get(id) != null) {
-      throw new _interface.InvalidParametersError('Stream already exists with that id');
+      throw new errors.InvalidParametersError('Stream already exists with that id');
     }
     const stream$1 = new stream.YamuxStream({
       id: id.toString(),
@@ -360,7 +361,7 @@ class YamuxMuxer {
           }
         default:
           // Invalid state
-          throw new errors.InvalidFrameError('Invalid frame type');
+          throw new errors$1.InvalidFrameError('Invalid frame type');
       }
     } else {
       switch (header.type) {
@@ -372,7 +373,7 @@ class YamuxMuxer {
           }
         default:
           // Invalid state
-          throw new errors.InvalidFrameError('Invalid frame type');
+          throw new errors$1.InvalidFrameError('Invalid frame type');
       }
     }
   }
@@ -386,17 +387,17 @@ class YamuxMuxer {
       this.handlePingResponse(header.length);
     } else {
       // Invalid state
-      throw new errors.InvalidFrameError('Invalid frame flag');
+      throw new errors$1.InvalidFrameError('Invalid frame flag');
     }
   }
   handlePingResponse(pingId) {
     if (this.activePing === undefined) {
       // this ping was not requested
-      throw new errors.UnrequestedPingError('ping not requested');
+      throw new errors$1.UnrequestedPingError('ping not requested');
     }
     if (this.activePing.id !== pingId) {
       // this ping doesn't match our active ping request
-      throw new errors.NotMatchingPingError('ping doesn\'t match our id');
+      throw new errors$1.NotMatchingPingError('ping doesn\'t match our id');
     }
     // valid ping response
     this.activePing.resolve();
@@ -453,7 +454,7 @@ class YamuxMuxer {
   }
   incomingStream(id) {
     if (this.client !== (id % 2 === 0)) {
-      throw new _interface.InvalidParametersError('Both endpoints are clients');
+      throw new errors.InvalidParametersError('Both endpoints are clients');
     }
     if (this._streams.has(id)) {
       return;
@@ -491,9 +492,9 @@ class YamuxMuxer {
     this.log?.trace('sending frame %o', header);
     if (header.type === frame.FrameType.Data) {
       if (data === undefined) {
-        throw new errors.InvalidFrameError('Invalid frame');
+        throw new errors$1.InvalidFrameError('Invalid frame');
       }
-      this.source.push(new index$1.Uint8ArrayList(encode.encodeHeader(header), data));
+      this.source.push(new index$2.Uint8ArrayList(encode.encodeHeader(header), data));
     } else {
       this.source.push(encode.encodeHeader(header));
     }

package/dist/cjs/node_modules/@chainsafe/libp2p-yamux/dist/src/stream.js

@@ -1,11 +1,11 @@
 'use strict';
 
-var _interface = require('@libp2p/interface');
 var abstractStream = require('../../../../@libp2p/utils/dist/src/abstract-stream.js');
 var index = require('../../../../it-foreach/dist/src/index.js');
 var constants = require('./constants.js');
 var errors = require('./errors.js');
 var frame = require('./frame.js');
+var errors$1 = require('../../../../@libp2p/interface/dist/src/errors.js');
 
 exports.StreamState = void 0;
 (function (StreamState) {
@@ -141,7 +141,7 @@ class YamuxStream extends abstractStream.AbstractStream {
     let reject;
     const abort = () => {
       if (this.status === 'open' || this.status === 'closing') {
-        reject(new _interface.AbortError('Stream aborted'));
+        reject(new errors$1.AbortError('Stream aborted'));
       } else {
         // the stream was closed already, ignore the failure to send
         resolve();

package/dist/cjs/node_modules/@helia/bitswap/dist/src/bitswap.js

@@ -0,0 +1,116 @@
+'use strict';
+
+var index$1 = require('../../../../any-signal/dist/src/index.js');
+var network = require('./network.js');
+var index = require('./peer-want-lists/index.js');
+var session = require('./session.js');
+var stats = require('./stats.js');
+var wantList = require('./want-list.js');
+var events_browser = require('../../../../@libp2p/interface/dist/src/events.browser.js');
+
+/**
+ * JavaScript implementation of the Bitswap 'data exchange' protocol
+ * used by IPFS.
+ */
+class Bitswap {
+  log;
+  logger;
+  stats;
+  network;
+  blockstore;
+  peerWantLists;
+  wantList;
+  libp2p;
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    this.logger = components.logger;
+    this.log = components.logger.forComponent('helia:bitswap');
+    this.blockstore = components.blockstore;
+    this.libp2p = components.libp2p;
+    // report stats to libp2p metrics
+    this.stats = new stats.Stats(components);
+    // the network delivers messages
+    this.network = new network.Network(components, init);
+    // handle which blocks we send to peers
+    this.peerWantLists = new index.PeerWantLists({
+      ...components,
+      network: this.network
+    }, init);
+    // handle which blocks we ask peers for
+    this.wantList = new wantList.WantList({
+      ...components,
+      network: this.network
+    }, init);
+  }
+  createSession() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return session.createBitswapSession({
+      wantList: this.wantList,
+      network: this.network,
+      logger: this.logger,
+      libp2p: this.libp2p
+    }, options);
+  }
+  async want(cid) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const controller = new AbortController();
+    const signal = index$1.anySignal([controller.signal, options.signal]);
+    events_browser.setMaxListeners(Infinity, controller.signal);
+    // find providers and connect to them
+    this.network.findAndConnect(cid, {
+      ...options,
+      signal
+    }).catch(err => {
+      // if the controller was aborted we found the block already so ignore
+      // the error
+      if (!controller.signal.aborted) {
+        this.log.error('error during finding and connect for cid %c', cid, err);
+      }
+    });
+    try {
+      const result = await this.wantList.wantBlock(cid, {
+        ...options,
+        signal
+      });
+      return result.block;
+    } finally {
+      // since we have the block we can now abort any outstanding attempts to
+      // find providers for it
+      controller.abort();
+      signal.clear();
+    }
+  }
+  /**
+   * Sends notifications about the arrival of a block
+   */
+  async notify(cid, block) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    await Promise.all([this.peerWantLists.receivedBlock(cid, options), this.wantList.receivedBlock(cid, options)]);
+  }
+  getWantlist() {
+    return [...this.wantList.wants.values()].filter(entry => !entry.cancel).map(entry => ({
+      cid: entry.cid,
+      priority: entry.priority,
+      wantType: entry.wantType
+    }));
+  }
+  getPeerWantlist(peer) {
+    return this.peerWantLists.wantListForPeer(peer);
+  }
+  /**
+   * Start the bitswap node
+   */
+  async start() {
+    this.wantList.start();
+    await this.network.start();
+  }
+  /**
+   * Stop the bitswap node
+   */
+  async stop() {
+    this.wantList.stop();
+    await this.network.stop();
+  }
+}
+
+exports.Bitswap = Bitswap;

package/dist/cjs/node_modules/@helia/bitswap/dist/src/constants.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const BITSWAP_120 = '/ipfs/bitswap/1.2.0';
+const DEFAULT_MAX_SIZE_REPLACE_HAS_WITH_BLOCK = 1024;
+const DEFAULT_MAX_INBOUND_STREAMS = 1024;
+const DEFAULT_MAX_OUTBOUND_STREAMS = 1024;
+const DEFAULT_MESSAGE_RECEIVE_TIMEOUT = 5000;
+const DEFAULT_MESSAGE_SEND_DELAY = 10;
+const DEFAULT_MESSAGE_SEND_CONCURRENCY = 50;
+const DEFAULT_RUN_ON_TRANSIENT_CONNECTIONS = false;
+const DEFAULT_MAX_PROVIDERS_PER_REQUEST = 3;
+const DEFAULT_MAX_OUTGOING_MESSAGE_SIZE = 1024 * 1024 * 4;
+const DEFAULT_MAX_INCOMING_MESSAGE_SIZE = DEFAULT_MAX_OUTGOING_MESSAGE_SIZE;
+
+exports.BITSWAP_120 = BITSWAP_120;
+exports.DEFAULT_MAX_INBOUND_STREAMS = DEFAULT_MAX_INBOUND_STREAMS;
+exports.DEFAULT_MAX_INCOMING_MESSAGE_SIZE = DEFAULT_MAX_INCOMING_MESSAGE_SIZE;
+exports.DEFAULT_MAX_OUTBOUND_STREAMS = DEFAULT_MAX_OUTBOUND_STREAMS;
+exports.DEFAULT_MAX_OUTGOING_MESSAGE_SIZE = DEFAULT_MAX_OUTGOING_MESSAGE_SIZE;
+exports.DEFAULT_MAX_PROVIDERS_PER_REQUEST = DEFAULT_MAX_PROVIDERS_PER_REQUEST;
+exports.DEFAULT_MAX_SIZE_REPLACE_HAS_WITH_BLOCK = DEFAULT_MAX_SIZE_REPLACE_HAS_WITH_BLOCK;
+exports.DEFAULT_MESSAGE_RECEIVE_TIMEOUT = DEFAULT_MESSAGE_RECEIVE_TIMEOUT;
+exports.DEFAULT_MESSAGE_SEND_CONCURRENCY = DEFAULT_MESSAGE_SEND_CONCURRENCY;
+exports.DEFAULT_MESSAGE_SEND_DELAY = DEFAULT_MESSAGE_SEND_DELAY;
+exports.DEFAULT_RUN_ON_TRANSIENT_CONNECTIONS = DEFAULT_RUN_ON_TRANSIENT_CONNECTIONS;

package/dist/cjs/node_modules/@helia/bitswap/dist/src/errors.js

@@ -0,0 +1,12 @@
+'use strict';
+
+class BlockTooLargeError extends Error {
+  static name = 'BlockTooLargeError';
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Block too large';
+    super(message);
+    this.name = 'BlockTooLargeError';
+  }
+}
+
+exports.BlockTooLargeError = BlockTooLargeError;

package/dist/cjs/node_modules/@helia/bitswap/dist/src/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var bitswap = require('./bitswap.js');
+
+/**
+ * @packageDocumentation
+ *
+ * This module implements the [Bitswap protocol](https://docs.ipfs.tech/concepts/bitswap/) in TypeScript.
+ *
+ * It supersedes the older [ipfs-bitswap](https://www.npmjs.com/package/ipfs-bitswap) module with the aim of being smaller, faster, better integrated with libp2p/helia, having fewer dependencies and using standard JavaScript instead of Node.js APIs.
+ */
+const createBitswap = function (components) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return new bitswap.Bitswap(components, options);
+};
+
+exports.createBitswap = createBitswap;

package/dist/cjs/node_modules/@helia/bitswap/dist/src/network.js

@@ -0,0 +1,274 @@
+'use strict';
+
+var peerQueue = require('../../../../@libp2p/utils/dist/src/peer-queue.js');
+var index$2 = require('../../../../it-drain/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$3 = require('../../../../it-map/dist/src/index.js');
+var index = require('../../../../it-pipe/dist/src/index.js');
+var index$4 = require('../../../../it-take/dist/src/index.js');
+var index$1 = require('../../../../progress-events/dist/src/index.js');
+var index$5 = require('../../../../race-event/dist/src/index.js');
+var constants = require('./constants.js');
+var message = require('./pb/message.js');
+var mergeMessages = require('./utils/merge-messages.js');
+var splitMessage = require('./utils/split-message.js');
+var errors = require('../../../../@libp2p/interface/dist/src/errors.js');
+var eventTarget = require('../../../../@libp2p/interface/dist/src/event-target.js');
+var events_browser = require('../../../../@libp2p/interface/dist/src/events.browser.js');
+
+class Network extends eventTarget.TypedEventEmitter {
+  log;
+  libp2p;
+  routing;
+  protocols;
+  running;
+  maxInboundStreams;
+  maxOutboundStreams;
+  messageReceiveTimeout;
+  registrarIds;
+  metrics;
+  sendQueue;
+  runOnLimitedConnections;
+  maxOutgoingMessageSize;
+  maxIncomingMessageSize;
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super();
+    this.log = components.logger.forComponent('helia:bitswap:network');
+    this.libp2p = components.libp2p;
+    this.routing = components.routing;
+    this.protocols = init.protocols ?? [constants.BITSWAP_120];
+    this.registrarIds = [];
+    this.running = false;
+    // bind event listeners
+    this._onStream = this._onStream.bind(this);
+    this.maxInboundStreams = init.maxInboundStreams ?? constants.DEFAULT_MAX_INBOUND_STREAMS;
+    this.maxOutboundStreams = init.maxOutboundStreams ?? constants.DEFAULT_MAX_OUTBOUND_STREAMS;
+    this.messageReceiveTimeout = init.messageReceiveTimeout ?? constants.DEFAULT_MESSAGE_RECEIVE_TIMEOUT;
+    this.runOnLimitedConnections = init.runOnLimitedConnections ?? constants.DEFAULT_RUN_ON_TRANSIENT_CONNECTIONS;
+    this.maxIncomingMessageSize = init.maxIncomingMessageSize ?? constants.DEFAULT_MAX_OUTGOING_MESSAGE_SIZE;
+    this.maxOutgoingMessageSize = init.maxOutgoingMessageSize ?? init.maxIncomingMessageSize ?? constants.DEFAULT_MAX_INCOMING_MESSAGE_SIZE;
+    this.metrics = {
+      blocksSent: components.metrics?.registerCounter('helia_bitswap_sent_blocks_total'),
+      dataSent: components.metrics?.registerCounter('helia_bitswap_sent_data_bytes_total')
+    };
+    this.sendQueue = new peerQueue.PeerQueue({
+      concurrency: init.messageSendConcurrency ?? constants.DEFAULT_MESSAGE_SEND_CONCURRENCY,
+      metrics: components.metrics,
+      metricName: 'helia_bitswap_message_send_queue'
+    });
+    this.sendQueue.addEventListener('error', evt => {
+      this.log.error('error sending wantlist to peer', evt.detail);
+    });
+  }
+  async start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    await this.libp2p.handle(this.protocols, this._onStream, {
+      maxInboundStreams: this.maxInboundStreams,
+      maxOutboundStreams: this.maxOutboundStreams,
+      runOnLimitedConnection: this.runOnLimitedConnections
+    });
+    // register protocol with topology
+    const topology = {
+      onConnect: peerId => {
+        this.safeDispatchEvent('peer:connected', {
+          detail: peerId
+        });
+      },
+      onDisconnect: peerId => {
+        this.safeDispatchEvent('peer:disconnected', {
+          detail: peerId
+        });
+      }
+    };
+    this.registrarIds = [];
+    for (const protocol of this.protocols) {
+      this.registrarIds.push(await this.libp2p.register(protocol, topology));
+    }
+    // All existing connections are like new ones for us
+    this.libp2p.getConnections().forEach(conn => {
+      this.safeDispatchEvent('peer:connected', {
+        detail: conn.remotePeer
+      });
+    });
+  }
+  async stop() {
+    this.running = false;
+    // Unhandle both, libp2p doesn't care if it's not already handled
+    await this.libp2p.unhandle(this.protocols);
+    // unregister protocol and handlers
+    if (this.registrarIds != null) {
+      for (const id of this.registrarIds) {
+        this.libp2p.unregister(id);
+      }
+      this.registrarIds = [];
+    }
+  }
+  /**
+   * Handles incoming bitswap messages
+   */
+  _onStream(info) {
+    if (!this.running) {
+      return;
+    }
+    const {
+      stream,
+      connection
+    } = info;
+    Promise.resolve().then(async () => {
+      this.log('incoming new bitswap %s stream from %p', stream.protocol, connection.remotePeer);
+      const abortListener = () => {
+        if (stream.status === 'open') {
+          stream.abort(new errors.TimeoutError(`Incoming Bitswap stream timed out after ${this.messageReceiveTimeout}ms`));
+        } else {
+          this.log('stream aborted with status %s', stream.status);
+        }
+      };
+      let signal = AbortSignal.timeout(this.messageReceiveTimeout);
+      signal.addEventListener('abort', abortListener);
+      await stream.closeWrite();
+      await index.pipe(stream, source => decode.decode(source, {
+        maxDataLength: this.maxIncomingMessageSize
+      }), async source => {
+        for await (const data of source) {
+          try {
+            const message$1 = message.BitswapMessage.decode(data);
+            this.log('incoming new bitswap %s message from %p on stream', stream.protocol, connection.remotePeer, stream.id);
+            this.safeDispatchEvent('bitswap:message', {
+              detail: {
+                peer: connection.remotePeer,
+                message: message$1
+              }
+            });
+            // we have received some data so reset the timeout controller
+            signal.removeEventListener('abort', abortListener);
+            signal = AbortSignal.timeout(this.messageReceiveTimeout);
+            events_browser.setMaxListeners(Infinity, signal);
+            signal.addEventListener('abort', abortListener);
+          } catch (err) {
+            this.log.error('error reading incoming bitswap message from %p on stream', connection.remotePeer, stream.id, err);
+            stream.abort(err);
+            break;
+          }
+        }
+      });
+    }).catch(err => {
+      this.log.error('error handling incoming stream from %p', connection.remotePeer, err);
+      stream.abort(err);
+    });
+  }
+  /**
+   * Find bitswap providers for a given `cid`.
+   */
+  async *findProviders(cid, options) {
+    options?.onProgress?.(new index$1.CustomProgressEvent('bitswap:network:find-providers', cid));
+    for await (const provider of this.routing.findProviders(cid, options)) {
+      // make sure we can dial the provider
+      const dialable = await this.libp2p.isDialable(provider.multiaddrs, {
+        runOnLimitedConnection: this.runOnLimitedConnections
+      });
+      if (!dialable) {
+        continue;
+      }
+      yield provider;
+    }
+  }
+  /**
+   * Find the providers of a given `cid` and connect to them.
+   */
+  async findAndConnect(cid, options) {
+    // connect to initial session providers if supplied
+    if (options?.providers != null) {
+      await Promise.all(options.providers.map(async prov => this.connectTo(prov).catch(err => {
+        this.log.error('could not connect to supplied provider - %e', err);
+      })));
+    }
+    // make a routing query to find additional providers
+    await index$2.default(index$3.default(index$4.default(this.findProviders(cid, options), options?.maxProviders ?? constants.DEFAULT_MAX_PROVIDERS_PER_REQUEST), async provider => this.connectTo(provider.id, options))).catch(err => {
+      this.log.error(err);
+    });
+  }
+  /**
+   * Connect to the given peer
+   * Send the given msg (instance of Message) to the given peer
+   */
+  async sendMessage(peerId, message, options) {
+    if (!this.running) {
+      throw new Error('network isn\'t running');
+    }
+    const existingJob = this.sendQueue.queue.find(job => {
+      return peerId.equals(job.options.peerId) && job.status === 'queued';
+    });
+    if (existingJob != null) {
+      existingJob.options.message = mergeMessages.mergeMessages(existingJob.options.message, message);
+      await existingJob.join({
+        signal: options?.signal
+      });
+      return;
+    }
+    await this.sendQueue.add(async options => {
+      const message = options?.message;
+      if (message == null) {
+        throw new errors.InvalidParametersError('No message to send');
+      }
+      this.log('sendMessage to %p', peerId);
+      options?.onProgress?.(new index$1.CustomProgressEvent('bitswap:network:send-wantlist', peerId));
+      const stream = await this.libp2p.dialProtocol(peerId, constants.BITSWAP_120, options);
+      await stream.closeRead();
+      try {
+        await index.pipe(splitMessage.splitMessage(message, this.maxOutgoingMessageSize), source => encode.encode(source), stream);
+        await stream.close(options);
+      } catch (err) {
+        options?.onProgress?.(new index$1.CustomProgressEvent('bitswap:network:send-wantlist:error', {
+          peer: peerId,
+          error: err
+        }));
+        this.log.error('error sending message to %p', peerId, err);
+        stream.abort(err);
+      }
+      this._updateSentStats(message.blocks);
+    }, {
+      peerId,
+      signal: options?.signal,
+      message
+    });
+  }
+  /**
+   * Connects to another peer
+   */
+  async connectTo(peer, options) {
+    if (!this.running) {
+      throw new errors.NotStartedError('Network isn\'t running');
+    }
+    options?.onProgress?.(new index$1.CustomProgressEvent('bitswap:network:dial', peer));
+    // dial and wait for identify - this is to avoid opening a protocol stream
+    // that we are not going to use but depends on the remote node running the
+    // identify protocol
+    const [connection] = await Promise.all([this.libp2p.dial(peer, options), index$5.raceEvent(this.libp2p, 'peer:identify', options?.signal, {
+      filter: evt => {
+        if (!evt.detail.peerId.equals(peer)) {
+          return false;
+        }
+        if (evt.detail.protocols.includes(constants.BITSWAP_120)) {
+          return true;
+        }
+        throw new errors.UnsupportedProtocolError(`${peer} did not support ${constants.BITSWAP_120}`);
+      }
+    })]);
+    return connection;
+  }
+  _updateSentStats(blocks) {
+    let bytes = 0;
+    for (const block of blocks.values()) {
+      bytes += block.data.byteLength;
+    }
+    this.metrics.dataSent?.increment(bytes);
+    this.metrics.blocksSent?.increment(blocks.size);
+  }
+}
+
+exports.Network = Network;