dexbot 1.4.12 → 1.4.14

package/claw/node_modules/btsdex-serializer/lib/SerializerValidation.js

@@ -0,0 +1,377 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _bytebuffer = require("bytebuffer");
+
+var _ChainTypes = _interopRequireDefault(require("./ChainTypes"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var MAX_SAFE_INT = 9007199254740991;
+var MIN_SAFE_INT = -9007199254740991;
+/**
+    Most validations are skipped and the value returned unchanged when an empty string, null, or undefined is encountered (except "required").
+
+    Validations support a string format for dealing with large numbers.
+*/
+
+var _my = {
+  is_empty: function (value) {
+    return value === null || value === undefined;
+  },
+
+  required(value, field_name = "") {
+    if (this.is_empty(value)) {
+      throw new Error(`value required ${field_name} ${value}`);
+    }
+
+    return value;
+  },
+
+  require_array: function (value, instance_require) {
+    if (!(value instanceof Array)) {
+      throw new Error(`array required`);
+    }
+
+    if (instance_require) {
+      value.forEach(i => {
+        instance_require(i);
+      });
+    }
+
+    return value;
+  },
+
+  require_long(value, field_name = "") {
+    if (!_bytebuffer.Long.isLong(value)) {
+      throw new Error(`Long value required ${field_name} ${value}`);
+    }
+
+    return value;
+  },
+
+  string(value) {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    if (typeof value !== "string") {
+      throw new Error(`string required: ${value}`);
+    }
+
+    return value;
+  },
+
+  number(value) {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    if (typeof value !== "number") {
+      throw new Error(`number required: ${value}`);
+    }
+
+    return value;
+  },
+
+  whole_number(value, field_name = "") {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    if (/\./.test(value)) {
+      throw new Error(`whole number required ${field_name} ${value}`);
+    }
+
+    return value;
+  },
+
+  unsigned(value, field_name = "") {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    if (/-/.test(value)) {
+      throw new Error(`unsigned required ${field_name} ${value}`);
+    }
+
+    return value;
+  },
+
+  is_digits: function (value) {
+    if (typeof value === "numeric") {
+      return true;
+    }
+
+    return /^[0-9]+$/.test(value);
+  },
+  to_number: function (value, field_name = "") {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    this.no_overflow53(value, field_name);
+
+    var int_value = (() => {
+      if (typeof value === "number") {
+        return value;
+      } else {
+        return parseInt(value);
+      }
+    })();
+
+    return int_value;
+  },
+
+  to_long(value, field_name = "", unsigned = false) {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    if (_bytebuffer.Long.isLong(value)) {
+      return value;
+    }
+
+    this.no_overflow64(value, field_name, unsigned);
+
+    if (typeof value === "number") {
+      value = "" + value;
+    }
+
+    return _bytebuffer.Long.fromString(value, unsigned);
+  },
+
+  to_string(value, field_name = "") {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    if (typeof value === "string") {
+      return value;
+    }
+
+    if (typeof value === "number") {
+      this.no_overflow53(value, field_name);
+      return "" + value;
+    }
+
+    if (_bytebuffer.Long.isLong(value)) {
+      return value.toString();
+    }
+
+    throw `unsupported type ${field_name}: (${typeof value}) ${value}`;
+  },
+
+  require_test(regex, value, field_name = "") {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    if (!regex.test(value)) {
+      throw new Error(`unmatched ${regex} ${field_name} ${value}`);
+    }
+
+    return value;
+  },
+
+  require_match: function (regex, value, field_name = "") {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    var match = value.match(regex);
+
+    if (match === null) {
+      throw new Error(`unmatched ${regex} ${field_name} ${value}`);
+    }
+
+    return match;
+  },
+  require_object_id: function (value, field_name) {
+    return require_match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/, value, field_name);
+  },
+
+  // Does not support over 53 bits
+  require_range(min, max, value, field_name = "") {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    var number = this.to_number(value);
+
+    if (value < min || value > max) {
+      throw new Error(`out of range ${value} ${field_name} ${value}`);
+    }
+
+    return value;
+  },
+
+  require_object_type: function (reserved_spaces = 1, type, value, field_name = "") {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    var object_type = _ChainTypes.default.object_type[type];
+
+    if (!object_type) {
+      throw new Error(`Unknown object type ${type} ${field_name} ${value}`);
+    }
+
+    var re = new RegExp(`${reserved_spaces}\.${object_type}\.[0-9]+$`);
+
+    if (!re.test(value)) {
+      throw new Error(`Expecting ${type} in format ` + `${reserved_spaces}.${object_type}.[0-9]+ ` + `instead of ${value} ${field_name} ${value}`);
+    }
+
+    return value;
+  },
+  get_instance: function (reserve_spaces, type, value, field_name) {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    this.require_object_type(reserve_spaces, type, value, field_name);
+    return this.to_number(value.split(".")[2]);
+  },
+  require_relative_type: function (type, value, field_name) {
+    this.require_object_type(0, type, value, field_name);
+    return value;
+  },
+  get_relative_instance: function (type, value, field_name) {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    this.require_object_type(0, type, value, field_name);
+    return this.to_number(value.split(".")[2]);
+  },
+  require_protocol_type: function (type, value, field_name) {
+    this.require_object_type(1, type, value, field_name);
+    return value;
+  },
+  get_protocol_instance: function (type, value, field_name) {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    this.require_object_type(1, type, value, field_name);
+    return this.to_number(value.split(".")[2]);
+  },
+  get_protocol_type: function (value, field_name) {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    this.require_object_id(value, field_name);
+    var values = value.split(".");
+    return this.to_number(values[1]);
+  },
+
+  get_protocol_type_name(value, field_name) {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    var type_id = this.get_protocol_type(value, field_name);
+    return Object.keys(_ChainTypes.default.object_type)[type_id];
+  },
+
+  require_implementation_type: function (type, value, field_name) {
+    this.require_object_type(2, type, value, field_name);
+    return value;
+  },
+  get_implementation_instance: function (type, value, field_name) {
+    if (this.is_empty(value)) {
+      return value;
+    }
+
+    this.require_object_type(2, type, value, field_name);
+    return this.to_number(value.split(".")[2]);
+  },
+
+  // signed / unsigned decimal
+  no_overflow53(value, field_name = "") {
+    if (typeof value === "number") {
+      if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) {
+        throw new Error(`overflow ${field_name} ${value}`);
+      }
+
+      return;
+    }
+
+    if (typeof value === "string") {
+      var int = parseInt(value);
+
+      if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) {
+        throw new Error(`overflow ${field_name} ${value}`);
+      }
+
+      return;
+    }
+
+    if (_bytebuffer.Long.isLong(value)) {
+      // typeof value.toInt() is 'number'
+      this.no_overflow53(value.toInt(), field_name);
+      return;
+    }
+
+    throw `unsupported type ${field_name}: (${typeof value}) ${value}`;
+  },
+
+  // signed / unsigned whole numbers only
+  no_overflow64(value, field_name = "", unsigned = false) {
+    // https://github.com/dcodeIO/Long.js/issues/20
+    if (_bytebuffer.Long.isLong(value)) {
+      return;
+    } // BigInteger#isBigInteger https://github.com/cryptocoinjs/bigi/issues/20
+
+
+    if (value.t !== undefined && value.s !== undefined) {
+      this.no_overflow64(value.toString(), field_name, unsigned);
+      return;
+    }
+
+    if (typeof value === "string") {
+      // remove leading zeros, will cause a false positive
+      value = value.replace(/^0+/, ""); // remove trailing zeros
+
+      while (/0$/.test(value)) {
+        value = value.substring(0, value.length - 1);
+      }
+
+      if (/\.$/.test(value)) {
+        // remove trailing dot
+        value = value.substring(0, value.length - 1);
+      }
+
+      if (value === "") {
+        value = "0";
+      }
+
+      var long_string = _bytebuffer.Long.fromString(value, unsigned).toString();
+
+      if (long_string !== value.trim()) {
+        throw new Error(`overflow ${field_name} ${value}`);
+      }
+
+      return;
+    }
+
+    if (typeof value === "number") {
+      if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) {
+        throw new Error(`overflow ${field_name} ${value}`);
+      }
+
+      return;
+    }
+
+    throw `unsupported type ${field_name}: (${typeof value}) ${value}`;
+  }
+
+};
+var _default = _my;
+exports.default = _default;

package/claw/node_modules/btsdex-serializer/lib/convert.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _bytebuffer = _interopRequireDefault(require("bytebuffer"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const Buffer = require("safe-buffer").Buffer;
+
+function _default(type) {
+  return {
+    fromHex(hex) {
+      var b = _bytebuffer.default.fromHex(hex, _bytebuffer.default.LITTLE_ENDIAN);
+
+      return type.fromByteBuffer(b);
+    },
+
+    toHex(object) {
+      var b = toByteBuffer(type, object);
+      return b.toHex();
+    },
+
+    fromBuffer(buffer) {
+      var b = _bytebuffer.default.fromBinary(buffer.toString(), _bytebuffer.default.LITTLE_ENDIAN);
+
+      return type.fromByteBuffer(b);
+    },
+
+    toBuffer(object) {
+      return Buffer.from(toByteBuffer(type, object).toBinary(), "binary");
+    },
+
+    fromBinary(string) {
+      var b = _bytebuffer.default.fromBinary(string, _bytebuffer.default.LITTLE_ENDIAN);
+
+      return type.fromByteBuffer(b);
+    },
+
+    toBinary(object) {
+      return toByteBuffer(type, object).toBinary();
+    }
+
+  };
+}
+
+var toByteBuffer = function (type, object) {
+  var b = new _bytebuffer.default(_bytebuffer.default.DEFAULT_CAPACITY, _bytebuffer.default.LITTLE_ENDIAN);
+  type.appendByteBuffer(b, object);
+  return b.copy(0, b.offset);
+};

package/claw/node_modules/btsdex-serializer/lib/error_with_cause.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/** Exception nesting.  */
+class ErrorWithCause {
+  constructor(message, cause) {
+    this.message = message;
+
+    if (typeof cause !== "undefined" && cause !== null ? cause.message : undefined) {
+      this.message = `cause\t${cause.message}\t` + this.message;
+    }
+
+    var stack = ""; //(new Error).stack
+
+    if (typeof cause !== "undefined" && cause !== null ? cause.stack : undefined) {
+      stack = `caused by\n\t${cause.stack}\t` + stack;
+    }
+
+    this.stack = this.message + "\n" + stack;
+  }
+
+  static throw(message, cause) {
+    var msg = message;
+
+    if (typeof cause !== "undefined" && cause !== null ? cause.message : undefined) {
+      msg += `\t cause: ${cause.message} `;
+    }
+
+    if (typeof cause !== "undefined" && cause !== null ? cause.stack : undefined) {
+      msg += `\n stack: ${cause.stack} `;
+    }
+
+    throw new Error(msg);
+  }
+
+}
+
+var _default = ErrorWithCause;
+exports.default = _default;

package/claw/node_modules/btsdex-serializer/lib/index.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Serializer", {
+  enumerable: true,
+  get: function () {
+    return _serializer.default;
+  }
+});
+Object.defineProperty(exports, "fp", {
+  enumerable: true,
+  get: function () {
+    return _FastParser.default;
+  }
+});
+Object.defineProperty(exports, "types", {
+  enumerable: true,
+  get: function () {
+    return _types.default;
+  }
+});
+Object.defineProperty(exports, "template", {
+  enumerable: true,
+  get: function () {
+    return _template.default;
+  }
+});
+Object.defineProperty(exports, "SerializerValidation", {
+  enumerable: true,
+  get: function () {
+    return _SerializerValidation.default;
+  }
+});
+Object.defineProperty(exports, "ChainTypes", {
+  enumerable: true,
+  get: function () {
+    return _ChainTypes.default;
+  }
+});
+Object.defineProperty(exports, "ObjectId", {
+  enumerable: true,
+  get: function () {
+    return _ObjectId.default;
+  }
+});
+exports.ops = void 0;
+
+var _serializer = _interopRequireDefault(require("./serializer"));
+
+var _FastParser = _interopRequireDefault(require("./FastParser"));
+
+var _types = _interopRequireDefault(require("./types"));
+
+var ops = _interopRequireWildcard(require("./operations"));
+
+exports.ops = ops;
+
+var _template = _interopRequireDefault(require("./template"));
+
+var _SerializerValidation = _interopRequireDefault(require("./SerializerValidation"));
+
+var _ChainTypes = _interopRequireDefault(require("./ChainTypes"));
+
+var _ObjectId = _interopRequireDefault(require("./ObjectId"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }