ccxt-look 1.81.50

package/js/static_dependencies/elliptic/lib/elliptic/utils.js

@@ -0,0 +1,214 @@
+'use strict';
+
+var utils = exports;
+var BN = require('../../../BN/bn');
+
+utils.assert = function (condition, errorMessage) {
+  if (!condition) {
+    throw new Error(errorMessage)
+  }
+};
+
+// Represent num in a w-NAF form
+function getNAF(num, w) {
+  var naf = [];
+  var ws = 1 << (w + 1);
+  var k = num.clone();
+  while (k.cmpn(1) >= 0) {
+    var z;
+    if (k.isOdd()) {
+      var mod = k.andln(ws - 1);
+      if (mod > (ws >> 1) - 1)
+        z = (ws >> 1) - mod;
+      else
+        z = mod;
+      k.isubn(z);
+    } else {
+      z = 0;
+    }
+    naf.push(z);
+
+    // Optimization, shift by word if possible
+    var shift = (k.cmpn(0) !== 0 && k.andln(ws - 1) === 0) ? (w + 1) : 1;
+    for (var i = 1; i < shift; i++)
+      naf.push(0);
+    k.iushrn(shift);
+  }
+
+  return naf;
+}
+utils.getNAF = getNAF;
+
+// Represent k1, k2 in a Joint Sparse Form
+function getJSF(k1, k2) {
+  var jsf = [
+    [],
+    []
+  ];
+
+  k1 = k1.clone();
+  k2 = k2.clone();
+  var d1 = 0;
+  var d2 = 0;
+  while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {
+
+    // First phase
+    var m14 = (k1.andln(3) + d1) & 3;
+    var m24 = (k2.andln(3) + d2) & 3;
+    if (m14 === 3)
+      m14 = -1;
+    if (m24 === 3)
+      m24 = -1;
+    var u1;
+    if ((m14 & 1) === 0) {
+      u1 = 0;
+    } else {
+      var m8 = (k1.andln(7) + d1) & 7;
+      if ((m8 === 3 || m8 === 5) && m24 === 2)
+        u1 = -m14;
+      else
+        u1 = m14;
+    }
+    jsf[0].push(u1);
+
+    var u2;
+    if ((m24 & 1) === 0) {
+      u2 = 0;
+    } else {
+      var m8 = (k2.andln(7) + d2) & 7;
+      if ((m8 === 3 || m8 === 5) && m14 === 2)
+        u2 = -m24;
+      else
+        u2 = m24;
+    }
+    jsf[1].push(u2);
+
+    // Second phase
+    if (2 * d1 === u1 + 1)
+      d1 = 1 - d1;
+    if (2 * d2 === u2 + 1)
+      d2 = 1 - d2;
+    k1.iushrn(1);
+    k2.iushrn(1);
+  }
+
+  return jsf;
+}
+utils.getJSF = getJSF;
+
+function cachedProperty(obj, name, computer) {
+  var key = '_' + name;
+  obj.prototype[name] = function cachedProperty() {
+    return this[key] !== undefined ? this[key] :
+           this[key] = computer.call(this);
+  };
+}
+utils.cachedProperty = cachedProperty;
+
+function parseBytes(bytes) {
+  return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') :
+                                     bytes;
+}
+utils.parseBytes = parseBytes;
+
+function intFromLE(bytes) {
+  return new BN(bytes, 'hex', 'le');
+}
+utils.intFromLE = intFromLE;
+
+// used to convert `CryptoJS` wordArrays into `crypto` hex buffers
+function wordToByteArray(word, length) {
+  var ba = [],
+      xFF = 0xFF;
+  if (length > 0)
+    ba.push(word >>> 24);
+  if (length > 1)
+    ba.push((word >>> 16) & xFF);
+  if (length > 2)
+    ba.push((word >>> 8) & xFF);
+  if (length > 3)
+    ba.push(word & xFF);
+
+  return ba;
+}
+
+function wordArrayToBuffer(wordArray) {
+  let length = undefined;
+  if (wordArray.hasOwnProperty("sigBytes") && wordArray.hasOwnProperty("words")) {
+    length = wordArray.sigBytes;
+    wordArray = wordArray.words;
+  } else {
+    throw Error('Argument not a wordArray')
+  }
+
+  const result = []
+  let bytes = []
+  let i = 0;
+  while (length > 0) {
+    bytes = wordToByteArray(wordArray[i], Math.min(4, length));
+    length -= bytes.length;
+    result.push(bytes);
+    i++;
+  }
+  return [].concat.apply([], result)
+}
+
+utils.wordArrayToBuffer = wordArrayToBuffer;
+
+// https://github.com/indutny/minimalistic-crypto-utils/blob/master/lib/utils.js
+// moved here to remove the dep
+
+function toArray(msg, enc) {
+  if (Array.isArray(msg))
+    return msg.slice();
+  if (!msg)
+    return [];
+  var res = [];
+  if (typeof msg !== 'string') {
+    for (var i = 0; i < msg.length; i++)
+      res[i] = msg[i] | 0;
+    return res;
+  }
+  if (enc === 'hex') {
+    msg = msg.replace(/[^a-z0-9]+/ig, '');
+    if (msg.length % 2 !== 0)
+      msg = '0' + msg;
+    for (var i = 0; i < msg.length; i += 2)
+      res.push(parseInt(msg[i] + msg[i + 1], 16));
+  } else {
+    for (var i = 0; i < msg.length; i++) {
+      var c = msg.charCodeAt(i);
+      var hi = c >> 8;
+      var lo = c & 0xff;
+      if (hi)
+        res.push(hi, lo);
+      else
+        res.push(lo);
+    }
+  }
+  return res;
+}
+utils.toArray = toArray;
+
+function zero2(word) {
+  if (word.length === 1)
+    return '0' + word;
+  else
+    return word;
+}
+utils.zero2 = zero2;
+
+function toHex(msg) {
+  var res = '';
+  for (var i = 0; i < msg.length; i++)
+    res += zero2(msg[i].toString(16));
+  return res;
+}
+utils.toHex = toHex;
+
+utils.encode = function encode(arr, enc) {
+  if (enc === 'hex')
+    return toHex(arr);
+  else
+    return arr;
+};

package/js/static_dependencies/elliptic/lib/elliptic.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var elliptic = exports;
+
+// hello ladies ;)
+function inherits (ctor, superCtor) {
+    ctor.super_ = superCtor;
+    var TempCtor = function () {};
+    TempCtor.prototype = superCtor.prototype;
+    ctor.prototype = new TempCtor();
+    ctor.prototype.constructor = ctor;
+}
+
+elliptic.inherits = inherits
+elliptic.version = '6.5.0';
+elliptic.utils = require('./elliptic/utils');
+elliptic.curve = require('./elliptic/curve');
+elliptic.curves = require('./elliptic/curves');
+
+// Protocols
+elliptic.ec = require('./elliptic/ec');
+elliptic.eddsa = require('./elliptic/eddsa');

package/js/static_dependencies/elliptic/lib/hmac-drbg/hmac-drbg.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var CryptoJS = require('../../../crypto-js/crypto-js');
+var assert = require('../elliptic/utils').assert;
+var utils = require ('../elliptic/utils')
+var { byteArrayToWordArray } = require('../../../../base/functions/encode');
+
+// some static stuff
+const ONE = CryptoJS.enc.Utf8.parse ('\x01')
+const ZERO = CryptoJS.enc.Utf8.parse ('\x00')
+
+function HmacDRBG(options) {
+  if (!(this instanceof HmacDRBG))
+    return new HmacDRBG(options);
+  this.hash = options.hash
+  this.predResist = !!options.predResist;
+
+  this.outLen = this.hash.slice (3, 6); // only support SHAXXX hashes
+  this.minEntropy = options.minEntropy || 192;
+
+  this._reseed = null;
+  this.reseedInterval = null;
+  this.K = null;
+  this.V = null;
+
+  var entropy = options.entropy
+  var nonce = options.nonce
+  var pers = []
+  assert(entropy.length >= (this.minEntropy / 8),
+         'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
+  this._init(entropy, nonce, pers);
+}
+module.exports = HmacDRBG;
+
+HmacDRBG.prototype._init = function init(entropy, nonce, pers) {
+  var seed = entropy.concat(nonce).concat(pers);
+
+  this.K = new CryptoJS.lib.WordArray.init ()
+  this.V = new CryptoJS.lib.WordArray.init ()
+  const magicNumber = (1 << 24) + (1 << 16) + (1 << 8) + 1
+  this.V.words = Array (this.outLen / 32).fill (magicNumber)
+  this.V.sigBytes = 32
+  this._update(seed);
+  this._reseed = 1;
+  this.reseedInterval = 0x1000000000000;  // 2^48
+};
+
+HmacDRBG.prototype._hmac = function hmac() {
+  return new CryptoJS.lib.WordArray.init ();
+};
+
+HmacDRBG.prototype._update = function update(seed) {
+  var kmac = this._hmac ()
+  kmac.concat (this.V)
+  kmac.concat (ZERO)
+  if (seed)
+    kmac.concat (byteArrayToWordArray (seed));
+  this.K = CryptoJS['Hmac' + this.hash] (kmac, this.K)
+  this.V = CryptoJS['Hmac' + this.hash] (this.V, this.K)
+  if (!seed)
+    return;
+
+  kmac = this._hmac ()
+  kmac.concat (this.V)
+  kmac.concat (ONE)
+  kmac.concat (byteArrayToWordArray (seed))
+  this.K = CryptoJS['Hmac' + this.hash] (kmac, this.K)
+  this.V = CryptoJS['Hmac' + this.hash] (this.V, this.K)
+};
+
+HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {
+  // Optional entropy enc
+  if (typeof entropyEnc !== 'string') {
+    addEnc = add;
+    add = entropyEnc;
+    entropyEnc = null;
+  }
+
+  //entropy = utils.toArray(entropy, entropyEnc);
+  //add = utils.toArray(add, addEnc);
+
+  assert(entropy.length >= (this.minEntropy / 8),
+         'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
+
+  this._update(entropy.concat(add || []));
+  this._reseed = 1;
+};
+
+HmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {
+  if (this._reseed > this.reseedInterval)
+    throw new Error ('Reseed is required');
+
+  // Optional encoding
+  if (typeof enc !== 'string') {
+    addEnc = add;
+    add = enc;
+    enc = null;
+  }
+
+  // Optional additional data
+  if (add) {
+    add = CryptoJS.enc.Utf8.parse (add);
+    this._update (add);
+  }
+
+  var res = new CryptoJS.lib.WordArray.init ();
+  while (res.sigBytes < len) {
+    this.V = CryptoJS['Hmac' + this.hash] (this.V, this.K)
+    res.concat (this.V);
+  }
+  this._update (add);
+  this._reseed++;
+  return utils.wordArrayToBuffer(res);
+};

package/js/static_dependencies/fetch-ponyfill/fetch-node.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var fetch = require('../node-fetch/index');
+
+function wrapFetchForNode(fetch) {
+  // Support schemaless URIs on the server for parity with the browser.
+  // https://github.com/matthew-andrews/isomorphic-fetch/pull/10
+  const f = function (u, options) {
+    if (typeof u === 'string' && u.slice(0, 2) === '//') {
+      return fetch('https:' + u, options);
+    }
+
+    return fetch(u, options);
+  };
+  // Igor Kroitor 2019 Dec 30
+  // expose http and https
+  // https://github.com/ccxt/ccxt/issues/6327
+  f.http = fetch.http;
+  f.https = fetch.https;
+  return f;
+}
+
+module.exports = function (context) {
+  // This modifies the global `node-fetch` object, which isn't great, since
+  // different callers to `fetch-ponyfill` which pass a different Promise
+  // implementation would each expect to have their implementation used. But,
+  // given the way `node-fetch` is implemented, this is the only way to make
+  // it work at all.
+  if (context && context.Promise) {
+    fetch.Promise = context.Promise;
+  }
+
+  return {
+    fetch: wrapFetchForNode(fetch),
+    Headers: fetch.Headers,
+    Request: fetch.Request,
+    Response: fetch.Response
+  };
+};