web-dc-api 0.0.58 → 0.0.59

package/dist/cjs/node_modules/@libp2p/autonat/dist/src/pb/index.js

@@ -0,0 +1,288 @@
+'use strict';
+
+var index = require('../../../../../protons-runtime/dist/src/index.js');
+var _enum = require('../../../../../protons-runtime/dist/src/codecs/enum.js');
+var message = require('../../../../../protons-runtime/dist/src/codecs/message.js');
+var encode = require('../../../../../protons-runtime/dist/src/encode.js');
+var decode = require('../../../../../protons-runtime/dist/src/decode.js');
+
+exports.Message = void 0;
+(function (Message) {
+  (function (MessageType) {
+    MessageType["DIAL"] = "DIAL";
+    MessageType["DIAL_RESPONSE"] = "DIAL_RESPONSE";
+  })(Message.MessageType || (Message.MessageType = {}));
+  let __MessageTypeValues;
+  (function (__MessageTypeValues) {
+    __MessageTypeValues[__MessageTypeValues["DIAL"] = 0] = "DIAL";
+    __MessageTypeValues[__MessageTypeValues["DIAL_RESPONSE"] = 1] = "DIAL_RESPONSE";
+  })(__MessageTypeValues || (__MessageTypeValues = {}));
+  (function (MessageType) {
+    MessageType.codec = () => {
+      return _enum.enumeration(__MessageTypeValues);
+    };
+  })(Message.MessageType || (Message.MessageType = {}));
+  (function (ResponseStatus) {
+    ResponseStatus["OK"] = "OK";
+    ResponseStatus["E_DIAL_ERROR"] = "E_DIAL_ERROR";
+    ResponseStatus["E_DIAL_REFUSED"] = "E_DIAL_REFUSED";
+    ResponseStatus["E_BAD_REQUEST"] = "E_BAD_REQUEST";
+    ResponseStatus["E_INTERNAL_ERROR"] = "E_INTERNAL_ERROR";
+  })(Message.ResponseStatus || (Message.ResponseStatus = {}));
+  let __ResponseStatusValues;
+  (function (__ResponseStatusValues) {
+    __ResponseStatusValues[__ResponseStatusValues["OK"] = 0] = "OK";
+    __ResponseStatusValues[__ResponseStatusValues["E_DIAL_ERROR"] = 100] = "E_DIAL_ERROR";
+    __ResponseStatusValues[__ResponseStatusValues["E_DIAL_REFUSED"] = 101] = "E_DIAL_REFUSED";
+    __ResponseStatusValues[__ResponseStatusValues["E_BAD_REQUEST"] = 200] = "E_BAD_REQUEST";
+    __ResponseStatusValues[__ResponseStatusValues["E_INTERNAL_ERROR"] = 300] = "E_INTERNAL_ERROR";
+  })(__ResponseStatusValues || (__ResponseStatusValues = {}));
+  (function (ResponseStatus) {
+    ResponseStatus.codec = () => {
+      return _enum.enumeration(__ResponseStatusValues);
+    };
+  })(Message.ResponseStatus || (Message.ResponseStatus = {}));
+  (function (PeerInfo) {
+    let _codec;
+    PeerInfo.codec = () => {
+      if (_codec == null) {
+        _codec = message.message(function (obj, w) {
+          let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+          if (opts.lengthDelimited !== false) {
+            w.fork();
+          }
+          if (obj.id != null) {
+            w.uint32(10);
+            w.bytes(obj.id);
+          }
+          if (obj.addrs != null) {
+            for (const value of obj.addrs) {
+              w.uint32(18);
+              w.bytes(value);
+            }
+          }
+          if (opts.lengthDelimited !== false) {
+            w.ldelim();
+          }
+        }, function (reader, length) {
+          let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+          const obj = {
+            addrs: []
+          };
+          const end = length == null ? reader.len : reader.pos + length;
+          while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1:
+                {
+                  obj.id = reader.bytes();
+                  break;
+                }
+              case 2:
+                {
+                  if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) {
+                    throw new index.MaxLengthError('Decode error - map field "addrs" had too many elements');
+                  }
+                  obj.addrs.push(reader.bytes());
+                  break;
+                }
+              default:
+                {
+                  reader.skipType(tag & 7);
+                  break;
+                }
+            }
+          }
+          return obj;
+        });
+      }
+      return _codec;
+    };
+    PeerInfo.encode = obj => {
+      return encode.encodeMessage(obj, PeerInfo.codec());
+    };
+    PeerInfo.decode = (buf, opts) => {
+      return decode.decodeMessage(buf, PeerInfo.codec(), opts);
+    };
+  })(Message.PeerInfo || (Message.PeerInfo = {}));
+  (function (Dial) {
+    let _codec;
+    Dial.codec = () => {
+      if (_codec == null) {
+        _codec = message.message(function (obj, w) {
+          let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+          if (opts.lengthDelimited !== false) {
+            w.fork();
+          }
+          if (obj.peer != null) {
+            w.uint32(10);
+            Message.PeerInfo.codec().encode(obj.peer, w);
+          }
+          if (opts.lengthDelimited !== false) {
+            w.ldelim();
+          }
+        }, function (reader, length) {
+          let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+          const obj = {};
+          const end = length == null ? reader.len : reader.pos + length;
+          while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1:
+                {
+                  obj.peer = Message.PeerInfo.codec().decode(reader, reader.uint32(), {
+                    limits: opts.limits?.peer
+                  });
+                  break;
+                }
+              default:
+                {
+                  reader.skipType(tag & 7);
+                  break;
+                }
+            }
+          }
+          return obj;
+        });
+      }
+      return _codec;
+    };
+    Dial.encode = obj => {
+      return encode.encodeMessage(obj, Dial.codec());
+    };
+    Dial.decode = (buf, opts) => {
+      return decode.decodeMessage(buf, Dial.codec(), opts);
+    };
+  })(Message.Dial || (Message.Dial = {}));
+  (function (DialResponse) {
+    let _codec;
+    DialResponse.codec = () => {
+      if (_codec == null) {
+        _codec = message.message(function (obj, w) {
+          let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+          if (opts.lengthDelimited !== false) {
+            w.fork();
+          }
+          if (obj.status != null) {
+            w.uint32(8);
+            Message.ResponseStatus.codec().encode(obj.status, w);
+          }
+          if (obj.statusText != null) {
+            w.uint32(18);
+            w.string(obj.statusText);
+          }
+          if (obj.addr != null) {
+            w.uint32(26);
+            w.bytes(obj.addr);
+          }
+          if (opts.lengthDelimited !== false) {
+            w.ldelim();
+          }
+        }, function (reader, length) {
+          const obj = {};
+          const end = length == null ? reader.len : reader.pos + length;
+          while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1:
+                {
+                  obj.status = Message.ResponseStatus.codec().decode(reader);
+                  break;
+                }
+              case 2:
+                {
+                  obj.statusText = reader.string();
+                  break;
+                }
+              case 3:
+                {
+                  obj.addr = reader.bytes();
+                  break;
+                }
+              default:
+                {
+                  reader.skipType(tag & 7);
+                  break;
+                }
+            }
+          }
+          return obj;
+        });
+      }
+      return _codec;
+    };
+    DialResponse.encode = obj => {
+      return encode.encodeMessage(obj, DialResponse.codec());
+    };
+    DialResponse.decode = (buf, opts) => {
+      return decode.decodeMessage(buf, DialResponse.codec(), opts);
+    };
+  })(Message.DialResponse || (Message.DialResponse = {}));
+  let _codec;
+  Message.codec = () => {
+    if (_codec == null) {
+      _codec = message.message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.type != null) {
+          w.uint32(8);
+          Message.MessageType.codec().encode(obj.type, w);
+        }
+        if (obj.dial != null) {
+          w.uint32(18);
+          Message.Dial.codec().encode(obj.dial, w);
+        }
+        if (obj.dialResponse != null) {
+          w.uint32(26);
+          Message.DialResponse.codec().encode(obj.dialResponse, w);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {};
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.type = Message.MessageType.codec().decode(reader);
+                break;
+              }
+            case 2:
+              {
+                obj.dial = Message.Dial.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.dial
+                });
+                break;
+              }
+            case 3:
+              {
+                obj.dialResponse = Message.DialResponse.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.dialResponse
+                });
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  Message.encode = obj => {
+    return encode.encodeMessage(obj, Message.codec());
+  };
+  Message.decode = (buf, opts) => {
+    return decode.decodeMessage(buf, Message.codec(), opts);
+  };
+})(exports.Message || (exports.Message = {}));

package/dist/cjs/node_modules/@libp2p/circuit-relay-v2/dist/src/constants.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+
+/**
+ * Multicodec code
+ */
+const CIRCUIT_PROTO_CODE = 290;
+/**
+ * How many reservation attempts to make in parallel
+ */
+const DEFAULT_RESERVATION_CONCURRENCY = 1;
+/**
+ * How long to wait for a reservation attempt to finish
+ */
+const DEFAULT_RESERVATION_COMPLETION_TIMEOUT = 2000;
+/**
+ * How long to let the reservation attempt queue to grow
+ */
+const DEFAULT_MAX_RESERVATION_QUEUE_LENGTH = 100;
+const KEEP_ALIVE_TAG = `${_interface.KEEP_ALIVE}-circuit-relay`;
+// 128k is the default data limit
+BigInt(1 << 17);
+/**
+ * The hop protocol
+ */
+const RELAY_V2_HOP_CODEC = '/libp2p/circuit/relay/0.2.0/hop';
+/**
+ * the stop protocol
+ */
+const RELAY_V2_STOP_CODEC = '/libp2p/circuit/relay/0.2.0/stop';
+const MAX_CONNECTIONS = 300;
+const DEFAULT_DISCOVERY_FILTER_SIZE = 4096;
+const DEFAULT_DISCOVERY_FILTER_ERROR_RATE = 0.001;
+
+exports.CIRCUIT_PROTO_CODE = CIRCUIT_PROTO_CODE;
+exports.DEFAULT_DISCOVERY_FILTER_ERROR_RATE = DEFAULT_DISCOVERY_FILTER_ERROR_RATE;
+exports.DEFAULT_DISCOVERY_FILTER_SIZE = DEFAULT_DISCOVERY_FILTER_SIZE;
+exports.DEFAULT_MAX_RESERVATION_QUEUE_LENGTH = DEFAULT_MAX_RESERVATION_QUEUE_LENGTH;
+exports.DEFAULT_RESERVATION_COMPLETION_TIMEOUT = DEFAULT_RESERVATION_COMPLETION_TIMEOUT;
+exports.DEFAULT_RESERVATION_CONCURRENCY = DEFAULT_RESERVATION_CONCURRENCY;
+exports.KEEP_ALIVE_TAG = KEEP_ALIVE_TAG;
+exports.MAX_CONNECTIONS = MAX_CONNECTIONS;
+exports.RELAY_V2_HOP_CODEC = RELAY_V2_HOP_CODEC;
+exports.RELAY_V2_STOP_CODEC = RELAY_V2_STOP_CODEC;

package/dist/cjs/node_modules/@libp2p/circuit-relay-v2/dist/src/errors.js

@@ -0,0 +1,31 @@
+'use strict';
+
+/**
+ * A transfer limit was hit
+ */
+/**
+ * There were enough relay reservations already
+ */
+class HadEnoughRelaysError extends Error {
+  static name = 'HadEnoughRelaysError';
+  name = 'HadEnoughRelaysError';
+}
+/**
+ * An attempt to open a relayed connection over a relayed connection was made
+ */
+class DoubleRelayError extends Error {
+  static name = 'DoubleRelayError';
+  name = 'DoubleRelayError';
+}
+/**
+ * An attempt to make a reservation on a relay was made while the reservation
+ * queue was full
+ */
+class RelayQueueFullError extends Error {
+  static name = 'RelayQueueFullError';
+  name = 'RelayQueueFullError';
+}
+
+exports.DoubleRelayError = DoubleRelayError;
+exports.HadEnoughRelaysError = HadEnoughRelaysError;
+exports.RelayQueueFullError = RelayQueueFullError;