dexbot 1.4.11 → 1.4.13

package/claw/node_modules/btsdex-ecc/lib/hash.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sha1 = sha1;
+exports.sha256 = sha256;
+exports.sha512 = sha512;
+exports.HmacSHA256 = HmacSHA256;
+exports.ripemd160 = ripemd160;
+
+var _createHash = _interopRequireDefault(require("create-hash"));
+
+var _createHmac = _interopRequireDefault(require("create-hmac"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/** @arg {string|Buffer} data
+    @arg {string} [digest = null] - 'hex', 'binary' or 'base64'
+    @return {string|Buffer} - Buffer when digest is null, or string
+*/
+function sha1(data, encoding) {
+  return (0, _createHash.default)("sha1").update(data).digest(encoding);
+}
+/** @arg {string|Buffer} data
+    @arg {string} [digest = null] - 'hex', 'binary' or 'base64'
+    @return {string|Buffer} - Buffer when digest is null, or string
+*/
+
+
+function sha256(data, encoding) {
+  return (0, _createHash.default)("sha256").update(data).digest(encoding);
+}
+/** @arg {string|Buffer} data
+    @arg {string} [digest = null] - 'hex', 'binary' or 'base64'
+    @return {string|Buffer} - Buffer when digest is null, or string
+*/
+
+
+function sha512(data, encoding) {
+  return (0, _createHash.default)("sha512").update(data).digest(encoding);
+}
+
+function HmacSHA256(buffer, secret) {
+  return (0, _createHmac.default)("sha256", secret).update(buffer).digest();
+}
+
+function ripemd160(data) {
+  return (0, _createHash.default)("rmd160").update(data).digest();
+} // function hash160(buffer) {
+//   return ripemd160(sha256(buffer))
+// }
+//
+// function hash256(buffer) {
+//   return sha256(sha256(buffer))
+// }
+//
+// function HmacSHA512(buffer, secret) {
+//   return crypto.createHmac('sha512', secret).update(buffer).digest()
+// }

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

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Address", {
+  enumerable: true,
+  get: function () {
+    return _address.default;
+  }
+});
+Object.defineProperty(exports, "Aes", {
+  enumerable: true,
+  get: function () {
+    return _aes.default;
+  }
+});
+Object.defineProperty(exports, "PrivateKey", {
+  enumerable: true,
+  get: function () {
+    return _PrivateKey.default;
+  }
+});
+Object.defineProperty(exports, "PublicKey", {
+  enumerable: true,
+  get: function () {
+    return _PublicKey.default;
+  }
+});
+Object.defineProperty(exports, "Signature", {
+  enumerable: true,
+  get: function () {
+    return _signature.default;
+  }
+});
+Object.defineProperty(exports, "brainKey", {
+  enumerable: true,
+  get: function () {
+    return _BrainKey.default;
+  }
+});
+Object.defineProperty(exports, "key", {
+  enumerable: true,
+  get: function () {
+    return _KeyUtils.default;
+  }
+});
+Object.defineProperty(exports, "setAddressPrefix", {
+  enumerable: true,
+  get: function () {
+    return _addressPrefix.setAddressPrefix;
+  }
+});
+Object.defineProperty(exports, "getAddressPrefix", {
+  enumerable: true,
+  get: function () {
+    return _addressPrefix.getAddressPrefix;
+  }
+});
+exports.hash = void 0;
+
+var _address = _interopRequireDefault(require("./address"));
+
+var _aes = _interopRequireDefault(require("./aes"));
+
+var _PrivateKey = _interopRequireDefault(require("./PrivateKey"));
+
+var _PublicKey = _interopRequireDefault(require("./PublicKey"));
+
+var _signature = _interopRequireDefault(require("./signature"));
+
+var _BrainKey = _interopRequireDefault(require("./BrainKey"));
+
+var hash = _interopRequireWildcard(require("./hash"));
+
+exports.hash = hash;
+
+var _KeyUtils = _interopRequireDefault(require("./KeyUtils"));
+
+var _addressPrefix = require("./addressPrefix");
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/claw/node_modules/btsdex-ecc/lib/signature.js

@@ -0,0 +1,185 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ecdsa = require("./ecdsa");
+
+var _hash2 = require("./hash");
+
+var _ecurve = require("ecurve");
+
+var _assert = _interopRequireDefault(require("assert"));
+
+var _bigi = _interopRequireDefault(require("bigi"));
+
+var _PublicKey = _interopRequireDefault(require("./PublicKey"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var secp256k1 = (0, _ecurve.getCurveByName)("secp256k1");
+
+const Buffer = require("safe-buffer").Buffer;
+
+class Signature {
+  constructor(r1, s1, i1) {
+    this.r = r1;
+    this.s = s1;
+    this.i = i1;
+
+    _assert.default.equal(this.r != null, true, "Missing parameter");
+
+    _assert.default.equal(this.s != null, true, "Missing parameter");
+
+    _assert.default.equal(this.i != null, true, "Missing parameter");
+  }
+
+  static fromBuffer(buf) {
+    var i, r, s;
+
+    _assert.default.equal(buf.length, 65, "Invalid signature length");
+
+    i = buf.readUInt8(0);
+
+    _assert.default.equal(i - 27, i - 27 & 7, "Invalid signature parameter");
+
+    r = _bigi.default.fromBuffer(buf.slice(1, 33));
+    s = _bigi.default.fromBuffer(buf.slice(33));
+    return new Signature(r, s, i);
+  }
+
+  toBuffer() {
+    var buf;
+    buf = Buffer.alloc(65);
+    buf.writeUInt8(this.i, 0);
+    this.r.toBuffer(32).copy(buf, 1);
+    this.s.toBuffer(32).copy(buf, 33);
+    return buf;
+  }
+
+  recoverPublicKeyFromBuffer(buffer) {
+    return this.recoverPublicKey((0, _hash2.sha256)(buffer));
+  }
+  /**
+        @return {PublicKey}
+    */
+
+
+  recoverPublicKey(sha256_buffer) {
+    let Q, e, i;
+    e = _bigi.default.fromBuffer(sha256_buffer);
+    i = this.i;
+    i -= 27;
+    i = i & 3;
+    Q = (0, _ecdsa.recoverPubKey)(secp256k1, e, this, i);
+    return _PublicKey.default.fromPoint(Q);
+  }
+  /**
+        @param {Buffer} buf
+        @param {PrivateKey} private_key
+        @return {Signature}
+    */
+
+
+  static signBuffer(buf, private_key) {
+    var _hash = (0, _hash2.sha256)(buf);
+
+    return Signature.signBufferSha256(_hash, private_key);
+  }
+  /** Sign a buffer of exactally 32 bytes in size (sha256(text))
+        @param {Buffer} buf - 32 bytes binary
+        @param {PrivateKey} private_key
+        @return {Signature}
+    */
+
+
+  static signBufferSha256(buf_sha256, private_key) {
+    if (buf_sha256.length !== 32 || !Buffer.isBuffer(buf_sha256)) throw new Error("buf_sha256: 32 byte buffer requred");
+    var der, e, ecsignature, i, lenR, lenS, nonce;
+    i = null;
+    nonce = 0;
+    e = _bigi.default.fromBuffer(buf_sha256);
+
+    while (true) {
+      ecsignature = (0, _ecdsa.sign)(secp256k1, buf_sha256, private_key.d, nonce++);
+      der = ecsignature.toDER();
+      lenR = der[3];
+      lenS = der[5 + lenR];
+
+      if (lenR === 32 && lenS === 32) {
+        i = (0, _ecdsa.calcPubKeyRecoveryParam)(secp256k1, e, ecsignature, private_key.toPublicKey().Q);
+        i += 4; // compressed
+
+        i += 27; // compact  //  24 or 27 :( forcing odd-y 2nd key candidate)
+
+        break;
+      }
+
+      if (nonce % 10 === 0) {
+        console.log("WARN: " + nonce + " attempts to find canonical signature");
+      }
+    }
+
+    return new Signature(ecsignature.r, ecsignature.s, i);
+  }
+
+  static sign(string, private_key) {
+    return Signature.signBuffer(Buffer.from(string), private_key);
+  }
+  /**
+        @param {Buffer} un-hashed
+        @param {./PublicKey}
+        @return {boolean}
+    */
+
+
+  verifyBuffer(buf, public_key) {
+    var _hash = (0, _hash2.sha256)(buf);
+
+    return this.verifyHash(_hash, public_key);
+  }
+
+  verifyHash(hash, public_key) {
+    _assert.default.equal(hash.length, 32, "A SHA 256 should be 32 bytes long, instead got " + hash.length);
+
+    return (0, _ecdsa.verify)(secp256k1, hash, {
+      r: this.r,
+      s: this.s
+    }, public_key.Q);
+  }
+  /* <HEX> */
+
+
+  toByteBuffer() {
+    var b;
+    b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    this.appendByteBuffer(b);
+    return b.copy(0, b.offset);
+  }
+
+  static fromHex(hex) {
+    return Signature.fromBuffer(Buffer.from(hex, "hex"));
+  }
+
+  toHex() {
+    return this.toBuffer().toString("hex");
+  }
+
+  static signHex(hex, private_key) {
+    var buf;
+    buf = Buffer.from(hex, "hex");
+    return Signature.signBuffer(buf, private_key);
+  }
+
+  verifyHex(hex, public_key) {
+    var buf;
+    buf = Buffer.from(hex, "hex");
+    return this.verifyBuffer(buf, public_key);
+  }
+
+}
+
+var _default = Signature;
+exports.default = _default;

package/claw/node_modules/btsdex-ecc/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "btsdex-ecc",
+  "version": "0.7.0",
+  "main": "lib",
+  "license": "MIT",
+  "scripts": {
+    "prebuild": "rm -rf lib build",
+    "build": "babel src -d lib",
+    "postbuild": "yarn browserify && yarn minify",
+    "browserify": "browserify lib/index.js --standalone btsdex-ecc -o build/btsdex-ecc.js -d",
+    "minify": "minify build/btsdex-ecc.js -o build/btsdex-ecc.min.js",
+    "dev": "nodemon --exec yarn build --watch src",
+    "test": "mocha --require @babel/register"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.2.3",
+    "@babel/core": "^7.3.4",
+    "@babel/preset-env": "^7.3.4",
+    "@babel/register": "^7.0.0",
+    "babel-minify": "^0.5.0",
+    "browserify": "^16.2.3",
+    "mocha": "^6.0.2",
+    "nodemon": "^1.18.10"
+  },
+  "dependencies": {
+    "assert": "^1.4.1",
+    "bigi": "^1.4.2",
+    "bs58": "^4.0.1",
+    "create-hash": "^1.2.0",
+    "create-hmac": "^1.1.7",
+    "crypto-js": "^3.1.9-1",
+    "deep-equal": "^1.0.1",
+    "ecurve": "^1.0.6",
+    "safe-buffer": "^5.1.2",
+    "secure-random": "^1.1.1"
+  }
+}

package/claw/node_modules/btsdex-serializer/.babelrc

@@ -0,0 +1,13 @@
+{
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "targets": {
+          "browsers": "> 5%",
+          "node": "12"
+        }
+      }
+    ]
+  ]
+}

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

@@ -0,0 +1,154 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+let ChainTypes = {};
+ChainTypes.reserved_spaces = {
+  relative_protocol_ids: 0,
+  protocol_ids: 1,
+  implementation_ids: 2
+};
+ChainTypes.object_type = {
+  null: 0,
+  base: 1,
+  account: 2,
+  asset: 3,
+  force_settlement: 4,
+  committee_member: 5,
+  witness: 6,
+  limit_order: 7,
+  call_order: 8,
+  custom: 9,
+  proposal: 10,
+  operation_history: 11,
+  withdraw_permission: 12,
+  vesting_balance: 13,
+  worker: 14,
+  balance: 15,
+  htlc: 16,
+  custom_active_authorities: 17,
+  // TODO: not active on the main net.
+  ticket: 18,
+  liquidity_pool: 19,
+  samet_fund: 20,
+  credit_offer: 21,
+  credit_deal: 22
+};
+ChainTypes.impl_object_type = {
+  global_property: 0,
+  dynamic_global_property: 1,
+  index_meta: 2,
+  asset_dynamic_data: 3,
+  asset_bitasset_data: 4,
+  account_balance: 5,
+  account_statistics: 6,
+  transaction: 7,
+  block_summary: 8,
+  account_transaction_history: 9,
+  blinded_balance: 10,
+  chain_property: 11,
+  witness_schedule: 12,
+  budget_record: 13,
+  special_authority: 14,
+  buyback: 15,
+  fba_accumulator: 16,
+  collateral_bid: 17,
+  credit_deal_summary: 18
+};
+ChainTypes.vote_type = {
+  committee: 0,
+  witness: 1,
+  worker: 2
+};
+ChainTypes.operations = {
+  transfer: 0,
+  limit_order_create: 1,
+  limit_order_cancel: 2,
+  call_order_update: 3,
+  fill_order: 4,
+  account_create: 5,
+  account_update: 6,
+  account_whitelist: 7,
+  account_upgrade: 8,
+  account_transfer: 9,
+  asset_create: 10,
+  asset_update: 11,
+  asset_update_bitasset: 12,
+  asset_update_feed_producers: 13,
+  asset_issue: 14,
+  asset_reserve: 15,
+  asset_fund_fee_pool: 16,
+  asset_settle: 17,
+  asset_global_settle: 18,
+  asset_publish_feed: 19,
+  witness_create: 20,
+  witness_update: 21,
+  proposal_create: 22,
+  proposal_update: 23,
+  proposal_delete: 24,
+  withdraw_permission_create: 25,
+  withdraw_permission_update: 26,
+  withdraw_permission_claim: 27,
+  withdraw_permission_delete: 28,
+  committee_member_create: 29,
+  committee_member_update: 30,
+  committee_member_update_global_parameters: 31,
+  vesting_balance_create: 32,
+  vesting_balance_withdraw: 33,
+  worker_create: 34,
+  custom: 35,
+  assert: 36,
+  balance_claim: 37,
+  override_transfer: 38,
+  transfer_to_blind: 39,
+  blind_transfer: 40,
+  transfer_from_blind: 41,
+  asset_settle_cancel: 42,
+  asset_claim_fees: 43,
+  fba_distribute: 44,
+  bid_collateral: 45,
+  execute_bid: 46,
+  asset_claim_pool: 47,
+  asset_update_issuer: 48,
+  htlc_create: 49,
+  htlc_redeem: 50,
+  htlc_redeemed: 51,
+  htlc_extend: 52,
+  htlc_refund: 53,
+  custom_authority_create: 54,
+  custom_authority_update: 55,
+  custom_authority_delete: 56,
+  ticket_create: 57,
+  ticket_update: 58,
+  liquidity_pool_create: 59,
+  liquidity_pool_delete: 60,
+  liquidity_pool_deposit: 61,
+  liquidity_pool_withdraw: 62,
+  liquidity_pool_exchange: 63,
+  samet_fund_create: 64,
+  samet_fund_delete: 65,
+  samet_fund_update: 66,
+  samet_fund_borrow: 67,
+  samet_fund_repay: 68,
+  credit_offer_create: 69,
+  credit_offer_delete: 70,
+  credit_offer_update: 71,
+  credit_offer_accept: 72,
+  credit_deal_repay: 73,
+  credit_deal_expired: 74,
+  // VIRTUAL
+  liquidity_pool_update: 75,
+  credit_deal_update: 76,
+  limit_order_update: 77
+};
+ChainTypes.ticket_type = {
+  liquid: 0,
+  lock_180_days: 1,
+  lock_360_days: 2,
+  lock_720_days: 3,
+  lock_forever: 4
+};
+var _default = ChainTypes;
+exports.default = _default;

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

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _btsdexEcc = require("btsdex-ecc");
+
+const Buffer = require("safe-buffer").Buffer;
+
+class FastParser {
+  static fixed_data(b, len, buffer) {
+    if (!b) {
+      return;
+    }
+
+    if (buffer) {
+      let data = buffer.slice(0, len).toString("binary");
+      b.append(data, "binary");
+
+      while (len-- > data.length) {
+        b.writeUint8(0);
+      }
+    } else {
+      let b_copy = b.copy(b.offset, b.offset + len);
+      b.skip(len);
+      return Buffer.from(b_copy.toBinary(), "binary");
+    }
+  }
+
+  static public_key(b, public_key) {
+    if (!b) {
+      return;
+    }
+
+    if (public_key) {
+      var buffer = public_key.toBuffer();
+      b.append(buffer.toString("binary"), "binary");
+      return;
+    } else {
+      buffer = FastParser.fixed_data(b, 33);
+      return _btsdexEcc.PublicKey.fromBuffer(buffer);
+    }
+  }
+
+  static ripemd160(b, ripemd160) {
+    if (!b) {
+      return;
+    }
+
+    if (ripemd160) {
+      FastParser.fixed_data(b, 20, ripemd160);
+      return;
+    } else {
+      return FastParser.fixed_data(b, 20);
+    }
+  }
+
+  static time_point_sec(b, epoch) {
+    if (epoch) {
+      epoch = Math.ceil(epoch / 1000);
+      b.writeInt32(epoch);
+      return;
+    } else {
+      epoch = b.readInt32(); // fc::time_point_sec
+
+      return new Date(epoch * 1000);
+    }
+  }
+
+}
+
+var _default = FastParser;
+exports.default = _default;

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

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _bytebuffer = require("bytebuffer");
+
+var _SerializerValidation = _interopRequireDefault(require("./SerializerValidation"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var DB_MAX_INSTANCE_ID = _bytebuffer.Long.fromNumber(Math.pow(2, 48) - 1);
+
+class ObjectId {
+  constructor(space, type, instance) {
+    this.space = space;
+    this.type = type;
+    this.instance = instance;
+    var instance_string = this.instance.toString();
+    var ObjectId = `${this.space}.${this.type}.${instance_string}`;
+
+    if (!_SerializerValidation.default.is_digits(instance_string)) {
+      throw new `Invalid object id ${ObjectId}`();
+    }
+  }
+
+  static fromString(value) {
+    if (value.space !== undefined && value.type !== undefined && value.instance !== undefined) {
+      return value;
+    }
+
+    var params = _SerializerValidation.default.require_match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/, _SerializerValidation.default.required(value, "ObjectId"), "ObjectId");
+
+    return new ObjectId(parseInt(params[1]), parseInt(params[2]), _bytebuffer.Long.fromString(params[3]));
+  }
+
+  static fromLong(long) {
+    var space = long.shiftRight(56).toInt();
+    var type = long.shiftRight(48).toInt() & 0x00ff;
+    var instance = long.and(DB_MAX_INSTANCE_ID);
+    return new ObjectId(space, type, instance);
+  }
+
+  static fromByteBuffer(b) {
+    return ObjectId.fromLong(b.readUint64());
+  }
+
+  toLong() {
+    return _bytebuffer.Long.fromNumber(this.space).shiftLeft(56).or(_bytebuffer.Long.fromNumber(this.type).shiftLeft(48).or(this.instance));
+  }
+
+  appendByteBuffer(b) {
+    return b.writeUint64(this.toLong());
+  }
+
+  toString() {
+    return `${this.space}.${this.type}.${this.instance.toString()}`;
+  }
+
+}
+
+var _default = ObjectId;
+exports.default = _default;