dexbot 1.4.12 → 1.4.13

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

@@ -0,0 +1,294 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _aes = _interopRequireDefault(require("crypto-js/aes"));
+
+var _encHex = _interopRequireDefault(require("crypto-js/enc-hex"));
+
+var _encBase = _interopRequireDefault(require("crypto-js/enc-base64"));
+
+var _assert = _interopRequireDefault(require("assert"));
+
+var _hash2 = require("./hash");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// https://code.google.com/p/crypto-js
+const Buffer = require("safe-buffer").Buffer;
+/** Provides symetric encrypt and decrypt via AES. */
+
+
+class Aes {
+  /** @private */
+  constructor(iv, key) {
+    this.iv = iv, this.key = key;
+  }
+  /** This is an excellent way to ensure that all references to Aes can not operate anymore (example: a wallet becomes locked).  An application should ensure there is only one Aes object instance for a given secret `seed`. */
+
+
+  clear() {
+    return this.iv = this.key = undefined;
+  }
+  /** @arg {string} seed - secret seed may be used to encrypt or decrypt. */
+
+
+  static fromSeed(seed) {
+    if (seed === undefined) {
+      throw new Error("seed is required");
+    }
+
+    var _hash = (0, _hash2.sha512)(seed);
+
+    _hash = _hash.toString("hex"); // DEBUG console.log('... fromSeed _hash',_hash)
+
+    return Aes.fromSha512(_hash);
+  }
+  /** @arg {string} hash - A 128 byte hex string, typically one would call {@link fromSeed} instead. */
+
+
+  static fromSha512(hash) {
+    _assert.default.equal(hash.length, 128, `A Sha512 in HEX should be 128 characters long, instead got ${hash.length}`);
+
+    var iv = _encHex.default.parse(hash.substring(64, 96));
+
+    var key = _encHex.default.parse(hash.substring(0, 64));
+
+    return new Aes(iv, key);
+  }
+
+  static fromBuffer(buf) {
+    (0, _assert.default)(Buffer.isBuffer(buf), "Expecting Buffer");
+
+    _assert.default.equal(buf.length, 64, `A Sha512 Buffer should be 64 characters long, instead got ${buf.length}`);
+
+    return Aes.fromSha512(buf.toString("hex"));
+  }
+  /**
+        @throws {Error} - "Invalid Key, ..."
+        @arg {PrivateKey} private_key - required and used for decryption
+        @arg {PublicKey} public_key - required and used to calcualte the shared secret
+        @arg {string} [nonce = ""] optional but should always be provided and be unique when re-using the same private/public keys more than once.  This nonce is not a secret.
+        @arg {string|Buffer} message - Encrypted message containing a checksum
+        @return {Buffer}
+    */
+
+
+  static decrypt_with_checksum(private_key, public_key, nonce, message, legacy = false) {
+    // Warning: Do not put `nonce = ""` in the arguments, in es6 this will not convert "null" into an emtpy string
+    if (nonce == null) // null or undefined
+      nonce = "";
+
+    if (!Buffer.isBuffer(message)) {
+      message = new Buffer(message, "hex");
+    }
+
+    var S = private_key.get_shared_secret(public_key, legacy); // D E B U G
+    // console.log('decrypt_with_checksum', {
+    //     priv_to_pub: private_key.toPublicKey().toString(),
+    //     pub: public_key.toPublicKeyString(),
+    //     nonce: nonce,
+    //     message: message.length,
+    //     S: S.toString('hex')
+    // })
+
+    var aes = Aes.fromSeed(Buffer.concat([// A null or empty string nonce will not effect the hash
+    Buffer.from("" + nonce), Buffer.from(S.toString("hex"))]));
+    var planebuffer = aes.decrypt(message);
+
+    if (!(planebuffer.length >= 4)) {
+      throw new Error("Invalid key, could not decrypt message(1)");
+    } // DEBUG console.log('... planebuffer',planebuffer)
+
+
+    var checksum = planebuffer.slice(0, 4);
+    var plaintext = planebuffer.slice(4); // console.log('... checksum',checksum.toString('hex'))
+    // console.log('... plaintext',plaintext.toString())
+
+    var new_checksum = (0, _hash2.sha256)(plaintext);
+    new_checksum = new_checksum.slice(0, 4);
+    new_checksum = new_checksum.toString("hex");
+
+    if (!(checksum.toString("hex") === new_checksum)) {
+      throw new Error("Invalid key, could not decrypt message(2)");
+    }
+
+    return plaintext;
+  }
+  /** Identical to {@link decrypt_with_checksum} but used to encrypt.  Should not throw an error.
+        @return {Buffer} message - Encrypted message which includes a checksum
+    */
+
+
+  static encrypt_with_checksum(private_key, public_key, nonce, message) {
+    // Warning: Do not put `nonce = ""` in the arguments, in es6 this will not convert "null" into an emtpy string
+    if (nonce == null) // null or undefined
+      nonce = "";
+
+    if (!Buffer.isBuffer(message)) {
+      message = new Buffer(message, "binary");
+    }
+
+    var S = private_key.get_shared_secret(public_key); // D E B U G
+    // console.log('encrypt_with_checksum', {
+    //     priv_to_pub: private_key.toPublicKey().toString()
+    //     pub: public_key.toPublicKeyString()
+    //     nonce: nonce
+    //     message: message.length
+    //     S: S.toString('hex')
+    // })
+
+    var aes = Aes.fromSeed(Buffer.concat([// A null or empty string nonce will not effect the hash
+    Buffer.from("" + nonce), Buffer.from(S.toString("hex"))])); // DEBUG console.log('... S',S.toString('hex'))
+
+    var checksum = (0, _hash2.sha256)(message).slice(0, 4);
+    var payload = Buffer.concat([checksum, message]); // DEBUG console.log('... payload',payload.toString())
+
+    return aes.encrypt(payload);
+  }
+  /** @private */
+
+
+  _decrypt_word_array(cipher) {
+    // https://code.google.com/p/crypto-js/#Custom_Key_and_IV
+    // see wallet_records.cpp master_key::decrypt_key
+    return _aes.default.decrypt({
+      ciphertext: cipher,
+      salt: null
+    }, this.key, {
+      iv: this.iv
+    });
+  }
+  /** @private */
+
+
+  _encrypt_word_array(plaintext) {
+    //https://code.google.com/p/crypto-js/issues/detail?id=85
+    var cipher = _aes.default.encrypt(plaintext, this.key, {
+      iv: this.iv
+    });
+
+    return _encBase.default.parse(cipher.toString());
+  }
+  /** This method does not use a checksum, the returned data must be validated some other way.
+        @arg {string} ciphertext
+        @return {Buffer} binary
+    */
+
+
+  decrypt(ciphertext) {
+    if (typeof ciphertext === "string") {
+      ciphertext = new Buffer(ciphertext, "binary");
+    }
+
+    if (!Buffer.isBuffer(ciphertext)) {
+      throw new Error("buffer required");
+    }
+
+    (0, _assert.default)(ciphertext, "Missing cipher text"); // hex is the only common format
+
+    var hex = this.decryptHex(ciphertext.toString("hex"));
+    return new Buffer(hex, "hex");
+  }
+  /** This method does not use a checksum, the returned data must be validated some other way.
+        @arg {string} plaintext
+        @return {Buffer} binary
+    */
+
+
+  encrypt(plaintext) {
+    if (typeof plaintext === "string") {
+      plaintext = new Buffer(plaintext, "binary");
+    }
+
+    if (!Buffer.isBuffer(plaintext)) {
+      throw new Error("buffer required");
+    } //assert plaintext, "Missing plain text"
+    // hex is the only common format
+
+
+    var hex = this.encryptHex(plaintext.toString("hex"));
+    return new Buffer(hex, "hex");
+  }
+  /** This method does not use a checksum, the returned data must be validated some other way.
+        @arg {string|Buffer} plaintext
+        @return {string} hex
+    */
+
+
+  encryptToHex(plaintext) {
+    if (typeof plaintext === "string") {
+      plaintext = new Buffer(plaintext, "binary");
+    }
+
+    if (!Buffer.isBuffer(plaintext)) {
+      throw new Error("buffer required");
+    } //assert plaintext, "Missing plain text"
+    // hex is the only common format
+
+
+    return this.encryptHex(plaintext.toString("hex"));
+  }
+  /** This method does not use a checksum, the returned data must be validated some other way.
+        @arg {string} cipher - hex
+        @return {string} binary (could easily be readable text)
+    */
+
+
+  decryptHex(cipher) {
+    (0, _assert.default)(cipher, "Missing cipher text"); // Convert data into word arrays (used by Crypto)
+
+    var cipher_array = _encHex.default.parse(cipher);
+
+    var plainwords = this._decrypt_word_array(cipher_array);
+
+    return _encHex.default.stringify(plainwords);
+  }
+  /** This method does not use a checksum, the returned data must be validated some other way.
+        @arg {string} cipher - hex
+        @return {Buffer} encoded as specified by the parameter
+    */
+
+
+  decryptHexToBuffer(cipher) {
+    (0, _assert.default)(cipher, "Missing cipher text"); // Convert data into word arrays (used by Crypto)
+
+    var cipher_array = _encHex.default.parse(cipher);
+
+    var plainwords = this._decrypt_word_array(cipher_array);
+
+    var plainhex = _encHex.default.stringify(plainwords);
+
+    return new Buffer(plainhex, "hex");
+  }
+  /** This method does not use a checksum, the returned data must be validated some other way.
+        @arg {string} cipher - hex
+        @arg {string} [encoding = 'binary'] - a valid Buffer encoding
+        @return {String} encoded as specified by the parameter
+    */
+
+
+  decryptHexToText(cipher, encoding = "binary") {
+    return this.decryptHexToBuffer(cipher).toString(encoding);
+  }
+  /** This method does not use a checksum, the returned data must be validated some other way.
+        @arg {string} plainhex - hex format
+        @return {String} hex
+    */
+
+
+  encryptHex(plainhex) {
+    var plain_array = _encHex.default.parse(plainhex);
+
+    var cipher_array = this._encrypt_word_array(plain_array);
+
+    return _encHex.default.stringify(cipher_array);
+  }
+
+}
+
+var _default = Aes;
+exports.default = _default;

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

@@ -0,0 +1,194 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calcPubKeyRecoveryParam = calcPubKeyRecoveryParam;
+exports.deterministicGenerateK = deterministicGenerateK;
+exports.recoverPubKey = recoverPubKey;
+exports.sign = sign;
+exports.verify = verify;
+exports.verifyRaw = verifyRaw;
+
+var _assert = _interopRequireDefault(require("assert"));
+
+var _hash = require("./hash");
+
+var _enforce_types = _interopRequireDefault(require("./enforce_types"));
+
+var _bigi = _interopRequireDefault(require("bigi"));
+
+var _ecsignature = _interopRequireDefault(require("./ecsignature"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// from github.com/bitcoinjs/bitcoinjs-lib from github.com/cryptocoinjs/ecdsa
+const Buffer = require("safe-buffer").Buffer; // https://tools.ietf.org/html/rfc6979#section-3.2
+
+
+function deterministicGenerateK(curve, hash, d, checkSig, nonce) {
+  (0, _enforce_types.default)("Buffer", hash);
+  (0, _enforce_types.default)(_bigi.default, d);
+
+  if (nonce) {
+    hash = (0, _hash.sha256)(Buffer.concat([hash, Buffer.alloc(nonce)]));
+  } // sanity check
+
+
+  _assert.default.equal(hash.length, 32, "Hash must be 256 bit");
+
+  var x = d.toBuffer(32);
+  var k = Buffer.alloc(32);
+  var v = Buffer.alloc(32); // Step B
+
+  v.fill(1); // Step C
+
+  k.fill(0); // Step D
+
+  k = (0, _hash.HmacSHA256)(Buffer.concat([v, new Buffer([0]), x, hash]), k); // Step E
+
+  v = (0, _hash.HmacSHA256)(v, k); // Step F
+
+  k = (0, _hash.HmacSHA256)(Buffer.concat([v, new Buffer([1]), x, hash]), k); // Step G
+
+  v = (0, _hash.HmacSHA256)(v, k); // Step H1/H2a, ignored as tlen === qlen (256 bit)
+  // Step H2b
+
+  v = (0, _hash.HmacSHA256)(v, k);
+
+  var T = _bigi.default.fromBuffer(v); // Step H3, repeat until T is within the interval [1, n - 1]
+
+
+  while (T.signum() <= 0 || T.compareTo(curve.n) >= 0 || !checkSig(T)) {
+    k = (0, _hash.HmacSHA256)(Buffer.concat([v, new Buffer([0])]), k);
+    v = (0, _hash.HmacSHA256)(v, k); // Step H1/H2a, again, ignored as tlen === qlen (256 bit)
+    // Step H2b again
+
+    v = (0, _hash.HmacSHA256)(v, k);
+    T = _bigi.default.fromBuffer(v);
+  }
+
+  return T;
+}
+
+function sign(curve, hash, d, nonce) {
+  const e = _bigi.default.fromBuffer(hash);
+
+  const n = curve.n;
+  const G = curve.G;
+  let r, s;
+  deterministicGenerateK(curve, hash, d, function (k) {
+    // find canonically valid signature
+    let Q = G.multiply(k);
+    if (curve.isInfinity(Q)) return false;
+    r = Q.affineX.mod(n);
+    if (r.signum() === 0) return false;
+    s = k.modInverse(n).multiply(e.add(d.multiply(r))).mod(n);
+    if (s.signum() === 0) return false;
+    return true;
+  }, nonce);
+  let N_OVER_TWO = n.shiftRight(1); // enforce low S values, see bip62: 'low s values in signatures'
+
+  if (s.compareTo(N_OVER_TWO) > 0) {
+    s = n.subtract(s);
+  }
+
+  return new _ecsignature.default(r, s);
+}
+
+function verifyRaw(curve, e, signature, Q) {
+  var n = curve.n;
+  var G = curve.G;
+  var r = signature.r;
+  var s = signature.s; // 1.4.1 Enforce r and s are both integers in the interval [1, n − 1]
+
+  if (r.signum() <= 0 || r.compareTo(n) >= 0) return false;
+  if (s.signum() <= 0 || s.compareTo(n) >= 0) return false; // c = s^-1 mod n
+
+  var c = s.modInverse(n); // 1.4.4 Compute u1 = es^−1 mod n
+  //               u2 = rs^−1 mod n
+
+  var u1 = e.multiply(c).mod(n);
+  var u2 = r.multiply(c).mod(n); // 1.4.5 Compute R = (xR, yR) = u1G + u2Q
+
+  var R = G.multiplyTwo(u1, Q, u2); // 1.4.5 (cont.) Enforce R is not at infinity
+
+  if (curve.isInfinity(R)) return false; // 1.4.6 Convert the field element R.x to an integer
+
+  var xR = R.affineX; // 1.4.7 Set v = xR mod n
+
+  var v = xR.mod(n); // 1.4.8 If v = r, output "valid", and if v != r, output "invalid"
+
+  return v.equals(r);
+}
+
+function verify(curve, hash, signature, Q) {
+  // 1.4.2 H = Hash(M), already done by the user
+  // 1.4.3 e = H
+  var e = _bigi.default.fromBuffer(hash);
+
+  return verifyRaw(curve, e, signature, Q);
+}
+/**
+ * Recover a public key from a signature.
+ *
+ * See SEC 1: Elliptic Curve Cryptography, section 4.1.6, "Public
+ * Key Recovery Operation".
+ *
+ * http://www.secg.org/download/aid-780/sec1-v2.pdf
+ */
+
+
+function recoverPubKey(curve, e, signature, i) {
+  _assert.default.strictEqual(i & 3, i, "Recovery param is more than two bits");
+
+  var n = curve.n;
+  var G = curve.G;
+  var r = signature.r;
+  var s = signature.s;
+  (0, _assert.default)(r.signum() > 0 && r.compareTo(n) < 0, "Invalid r value");
+  (0, _assert.default)(s.signum() > 0 && s.compareTo(n) < 0, "Invalid s value"); // A set LSB signifies that the y-coordinate is odd
+
+  var isYOdd = i & 1; // The more significant bit specifies whether we should use the
+  // first or second candidate key.
+
+  var isSecondKey = i >> 1; // 1.1 Let x = r + jn
+
+  var x = isSecondKey ? r.add(n) : r;
+  var R = curve.pointFromX(isYOdd, x); // 1.4 Check that nR is at infinity
+
+  var nR = R.multiply(n);
+  (0, _assert.default)(curve.isInfinity(nR), "nR is not a valid curve point"); // Compute -e from e
+
+  var eNeg = e.negate().mod(n); // 1.6.1 Compute Q = r^-1 (sR -  eG)
+  //               Q = r^-1 (sR + -eG)
+
+  var rInv = r.modInverse(n);
+  var Q = R.multiplyTwo(s, G, eNeg).multiply(rInv);
+  curve.validate(Q);
+  return Q;
+}
+/**
+ * Calculate pubkey extraction parameter.
+ *
+ * When extracting a pubkey from a signature, we have to
+ * distinguish four different cases. Rather than putting this
+ * burden on the verifier, Bitcoin includes a 2-bit value with the
+ * signature.
+ *
+ * This function simply tries all four cases and returns the value
+ * that resulted in a successful pubkey recovery.
+ */
+
+
+function calcPubKeyRecoveryParam(curve, e, signature, Q) {
+  for (var i = 0; i < 4; i++) {
+    var Qprime = recoverPubKey(curve, e, signature, i); // 1.6.2 Verify Q
+
+    if (Qprime.equals(Q)) {
+      return i;
+    }
+  }
+
+  throw new Error("Unable to find valid recovery factor");
+}

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

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _assert = _interopRequireDefault(require("assert"));
+
+var _enforce_types = _interopRequireDefault(require("./enforce_types"));
+
+var _bigi = _interopRequireDefault(require("bigi"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// from https://github.com/bitcoinjs/bitcoinjs-lib
+const Buffer = require("safe-buffer").Buffer;
+
+function ECSignature(r, s) {
+  (0, _enforce_types.default)(_bigi.default, r);
+  (0, _enforce_types.default)(_bigi.default, s);
+  this.r = r;
+  this.s = s;
+} // Import operations
+
+
+ECSignature.parseCompact = function (buffer) {
+  _assert.default.equal(buffer.length, 65, "Invalid signature length");
+
+  var i = buffer.readUInt8(0) - 27; // At most 3 bits
+
+  _assert.default.equal(i, i & 7, "Invalid signature parameter");
+
+  var compressed = !!(i & 4); // Recovery param only
+
+  i = i & 3;
+
+  var r = _bigi.default.fromBuffer(buffer.slice(1, 33));
+
+  var s = _bigi.default.fromBuffer(buffer.slice(33));
+
+  return {
+    compressed: compressed,
+    i: i,
+    signature: new ECSignature(r, s)
+  };
+};
+
+ECSignature.fromDER = function (buffer) {
+  _assert.default.equal(buffer.readUInt8(0), 0x30, "Not a DER sequence");
+
+  _assert.default.equal(buffer.readUInt8(1), buffer.length - 2, "Invalid sequence length");
+
+  _assert.default.equal(buffer.readUInt8(2), 0x02, "Expected a DER integer");
+
+  var rLen = buffer.readUInt8(3);
+  (0, _assert.default)(rLen > 0, "R length is zero");
+  var offset = 4 + rLen;
+
+  _assert.default.equal(buffer.readUInt8(offset), 0x02, "Expected a DER integer (2)");
+
+  var sLen = buffer.readUInt8(offset + 1);
+  (0, _assert.default)(sLen > 0, "S length is zero");
+  var rB = buffer.slice(4, offset);
+  var sB = buffer.slice(offset + 2);
+  offset += 2 + sLen;
+
+  if (rLen > 1 && rB.readUInt8(0) === 0x00) {
+    (0, _assert.default)(rB.readUInt8(1) & 0x80, "R value excessively padded");
+  }
+
+  if (sLen > 1 && sB.readUInt8(0) === 0x00) {
+    (0, _assert.default)(sB.readUInt8(1) & 0x80, "S value excessively padded");
+  }
+
+  _assert.default.equal(offset, buffer.length, "Invalid DER encoding");
+
+  var r = _bigi.default.fromDERInteger(rB);
+
+  var s = _bigi.default.fromDERInteger(sB);
+
+  (0, _assert.default)(r.signum() >= 0, "R value is negative");
+  (0, _assert.default)(s.signum() >= 0, "S value is negative");
+  return new ECSignature(r, s);
+}; // FIXME: 0x00, 0x04, 0x80 are SIGHASH_* boundary constants, importing Transaction causes a circular dependency
+
+
+ECSignature.parseScriptSignature = function (buffer) {
+  var hashType = buffer.readUInt8(buffer.length - 1);
+  var hashTypeMod = hashType & ~0x80;
+  (0, _assert.default)(hashTypeMod > 0x00 && hashTypeMod < 0x04, "Invalid hashType");
+  return {
+    signature: ECSignature.fromDER(buffer.slice(0, -1)),
+    hashType: hashType
+  };
+}; // Export operations
+
+
+ECSignature.prototype.toCompact = function (i, compressed) {
+  if (compressed) i += 4;
+  i += 27;
+  var buffer = Buffer.alloc(65);
+  buffer.writeUInt8(i, 0);
+  this.r.toBuffer(32).copy(buffer, 1);
+  this.s.toBuffer(32).copy(buffer, 33);
+  return buffer;
+};
+
+ECSignature.prototype.toDER = function () {
+  var rBa = this.r.toDERInteger();
+  var sBa = this.s.toDERInteger();
+  var sequence = []; // INTEGER
+
+  sequence.push(0x02, rBa.length);
+  sequence = sequence.concat(rBa); // INTEGER
+
+  sequence.push(0x02, sBa.length);
+  sequence = sequence.concat(sBa); // SEQUENCE
+
+  sequence.unshift(0x30, sequence.length);
+  return Buffer.from(sequence);
+};
+
+ECSignature.prototype.toScriptSignature = function (hashType) {
+  var hashTypeBuffer = Buffer.alloc(1);
+  hashTypeBuffer.writeUInt8(hashType, 0);
+  return Buffer.concat([this.toDER(), hashTypeBuffer]);
+};
+
+var _default = ECSignature;
+exports.default = _default;

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

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = enforce;
+
+function enforce(type, value) {
+  // Copied from https://github.com/bitcoinjs/bitcoinjs-lib
+  switch (type) {
+    case "Array":
+      {
+        if (Array.isArray(value)) return;
+        break;
+      }
+
+    case "Boolean":
+      {
+        if (typeof value === "boolean") return;
+        break;
+      }
+
+    case "Buffer":
+      {
+        if (Buffer.isBuffer(value)) return;
+        break;
+      }
+
+    case "Number":
+      {
+        if (typeof value === "number") return;
+        break;
+      }
+
+    case "String":
+      {
+        if (typeof value === "string") return;
+        break;
+      }
+
+    default:
+      {
+        if (getName(value.constructor) === getName(type)) return;
+      }
+  }
+
+  throw new TypeError("Expected " + (getName(type) || type) + ", got " + value);
+}
+
+function getName(fn) {
+  // Why not fn.name: https://kangax.github.io/compat-table/es6/#function_name_property
+  var match = fn.toString().match(/function (.*?)\(/);
+  return match ? match[1] : null;
+}