ccxt 4.2.11 → 4.2.13

package/dist/cjs/js/src/base/functions/string.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// ----------------------------------------------------------------------------
+// unCamelCase has to work with the following edge cases
+//
+//     parseOHLCVs               > parse_ohlcvs
+//     safeString2               > safe_string_2
+//     safeStringN               > safe_string_n
+//     convertOHLCVToTradingView > convert_ohlcv_to_trading_view
+//     fetchL2OrderBook          > fetch_l2_order_book
+//     stringToBase64            > string_to_base64
+//     base64ToString            > base64_to_string
+//     parseHTTPResponse         > parse_http_response
+//     hasFetchOHLCV             > has_fetch_ohlcv
+//
+// @ts-nocheck
+const unCamelCase = (s) => {
+    const exceptions = {
+        'fetchOHLCVWs': 'fetch_ohlcv_ws', // ws = websocket
+    };
+    if (exceptions[s]) {
+        return exceptions[s];
+    }
+    return s.match(/[A-Z]/) ? s.replace(/[a-z0-9][A-Z]/g, (x) => x[0] + '_' + x[1]).replace(/[A-Z0-9][A-Z0-9][a-z][^$]/g, (x) => x[0] + '_' + x[1] + x[2] + x[3]).replace(/[a-z][0-9]$/g, (x) => x[0] + '_' + x[1]).toLowerCase() : s;
+};
+const capitalize = (s) => {
+    return s.length ? (s.charAt(0).toUpperCase() + s.slice(1)) : s;
+};
+const strip = (s) => s.replace(/^\s+|\s+$/g, '');
+// ----------------------------------------------------------------------------
+const uuid = (a) => {
+    return a ? (a ^ Math.random() * 16 >> a / 4).toString(16) : ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, uuid);
+};
+const uuid16 = (a) => {
+    return a ? (a ^ Math.random() * 16 >> a / 4).toString(16) : ([1e5] + 1e2 + 4e2 + 8e3).replace(/[018]/g, uuid16);
+};
+const uuid22 = (a) => {
+    return a ? (a ^ Math.random() * 16 >> a / 4).toString(16) : ([1e7] + 1e3 + 4e3 + 8e5).replace(/[018]/g, uuid22);
+};
+
+exports.capitalize = capitalize;
+exports.strip = strip;
+exports.unCamelCase = unCamelCase;
+exports.uuid = uuid;
+exports.uuid16 = uuid16;
+exports.uuid22 = uuid22;

package/dist/cjs/js/src/base/functions/throttle.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var time = require('./time.js');
+
+//@ts-nocheck
+/*  ------------------------------------------------------------------------ */
+class Throttler {
+    constructor(config) {
+        this.config = {
+            'refillRate': 1.0,
+            'delay': 0.001,
+            'capacity': 1.0,
+            'maxCapacity': 2000,
+            'tokens': 0,
+            'cost': 1.0,
+        };
+        Object.assign(this.config, config);
+        this.queue = [];
+        this.running = false;
+    }
+    async loop() {
+        let lastTimestamp = time.now();
+        while (this.running) {
+            const { resolver, cost } = this.queue[0];
+            if (this.config['tokens'] >= 0) {
+                this.config['tokens'] -= cost;
+                resolver();
+                this.queue.shift();
+                // contextswitch
+                await Promise.resolve();
+                if (this.queue.length === 0) {
+                    this.running = false;
+                }
+            }
+            else {
+                await time.sleep(this.config['delay'] * 1000);
+                const current = time.now();
+                const elapsed = current - lastTimestamp;
+                lastTimestamp = current;
+                const tokens = this.config['tokens'] + (this.config['refillRate'] * elapsed);
+                this.config['tokens'] = Math.min(tokens, this.config['capacity']);
+            }
+        }
+    }
+    throttle(cost = undefined) {
+        let resolver;
+        const promise = new Promise((resolve, reject) => {
+            resolver = resolve;
+        });
+        if (this.queue.length > this.config['maxCapacity']) {
+            throw new Error('throttle queue is over maxCapacity (' + this.config['maxCapacity'].toString() + '), see https://github.com/ccxt/ccxt/issues/11645#issuecomment-1195695526');
+        }
+        cost = (cost === undefined) ? this.config['cost'] : cost;
+        this.queue.push({ resolver, cost });
+        if (!this.running) {
+            this.running = true;
+            this.loop();
+        }
+        return promise;
+    }
+}
+// ----------------------------------------
+
+exports.Throttler = Throttler;

package/dist/cjs/js/src/base/functions/time.js

@@ -0,0 +1,187 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// @ts-nocheck
+const now = Date.now; // TODO: figure out how to utilize performance.now () properly – it's not as easy as it does not return a unix timestamp...
+const microseconds = () => now() * 1000; // TODO: utilize performance.now for that purpose
+const milliseconds = now;
+const seconds = () => Math.floor(now() / 1000);
+const uuidv1 = () => {
+    const biasSeconds = 12219292800; // seconds from 15th Oct 1572 to Jan 1st 1970
+    const bias = biasSeconds * 10000000; // in hundreds of nanoseconds
+    const time = microseconds() * 10 + bias;
+    const timeHex = time.toString(16);
+    const arranged = timeHex.slice(7, 15) + timeHex.slice(3, 7) + '1' + timeHex.slice(0, 3);
+    // these should be random, but we're not making more than 10 requests per microsecond so who cares
+    const clockId = '9696'; // a 14 bit number
+    const macAddress = 'ff'.repeat(6);
+    return arranged + clockId + macAddress;
+};
+const setTimeout_original = setTimeout;
+const setTimeout_safe = (done, ms, setTimeout = setTimeout_original /* overrideable for mocking purposes */, targetTime = now() + ms) => {
+    // avoid MAX_INT issue https://github.com/ccxt/ccxt/issues/10761
+    if (ms >= 2147483647) {
+        throw new Error('setTimeout() function was called with unrealistic value of ' + ms.toString());
+    }
+    // The built-in setTimeout function can fire its callback earlier than specified, so we
+    // need to ensure that it does not happen: sleep recursively until `targetTime` is reached...
+    let clearInnerTimeout = () => { };
+    let active = true;
+    const id = setTimeout(() => {
+        active = true;
+        const rest = targetTime - now();
+        if (rest > 0) {
+            clearInnerTimeout = setTimeout_safe(done, rest, setTimeout, targetTime); // try sleep more
+        }
+        else {
+            done();
+        }
+    }, ms);
+    return function clear() {
+        if (active) {
+            active = false; // dunno if IDs are unique on various platforms, so it's better to rely on this flag to exclude the possible cancellation of the wrong timer (if called after completion)
+            clearTimeout(id);
+        }
+        clearInnerTimeout();
+    };
+};
+class TimedOut extends Error {
+    constructor() {
+        const message = 'timed out';
+        super(message);
+        this.constructor = TimedOut;
+        // // @ts-expect-error
+        this.__proto__ = TimedOut.prototype;
+        this.message = message;
+    }
+}
+const iso8601 = (timestamp) => {
+    let _timestampNumber = undefined;
+    if (typeof timestamp === 'number') {
+        _timestampNumber = Math.floor(timestamp);
+    }
+    else {
+        _timestampNumber = parseInt(timestamp, 10);
+    }
+    // undefined, null and lots of nasty non-numeric values yield NaN
+    if (Number.isNaN(_timestampNumber) || _timestampNumber < 0) {
+        return undefined;
+    }
+    // last line of defence
+    try {
+        return new Date(_timestampNumber).toISOString();
+    }
+    catch (e) {
+        return undefined;
+    }
+};
+const parse8601 = (x) => {
+    if (typeof x !== 'string' || !x) {
+        return undefined;
+    }
+    if (x.match(/^[0-9]+$/)) {
+        // a valid number in a string, not a date.
+        return undefined;
+    }
+    if (x.indexOf('-') < 0 || x.indexOf(':') < 0) { // no date can be without a dash and a colon
+        return undefined;
+    }
+    // last line of defence
+    try {
+        const candidate = Date.parse(((x.indexOf('+') >= 0) || (x.slice(-1) === 'Z')) ? x : (x + 'Z').replace(/\s(\d\d):/, 'T$1:'));
+        if (Number.isNaN(candidate)) {
+            return undefined;
+        }
+        return candidate;
+    }
+    catch (e) {
+        return undefined;
+    }
+};
+const parseDate = (x) => {
+    if (typeof x !== 'string' || !x) {
+        return undefined;
+    }
+    if (x.indexOf('GMT') >= 0) {
+        try {
+            return Date.parse(x);
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    return parse8601(x);
+};
+const rfc2616 = (timestamp = undefined) => new Date(timestamp).toUTCString();
+const mdy = (timestamp, infix = '-') => {
+    infix = infix || '';
+    const date = new Date(timestamp);
+    const Y = date.getUTCFullYear().toString();
+    let m = date.getUTCMonth() + 1;
+    let d = date.getUTCDate();
+    m = m < 10 ? ('0' + m) : m.toString();
+    d = d < 10 ? ('0' + d) : d.toString();
+    return m + infix + d + infix + Y;
+};
+const ymd = (timestamp, infix, fullYear = true) => {
+    infix = infix || '';
+    const date = new Date(timestamp);
+    const intYear = date.getUTCFullYear();
+    const year = fullYear ? intYear : (intYear - 2000);
+    const Y = year.toString();
+    let m = date.getUTCMonth() + 1;
+    let d = date.getUTCDate();
+    m = m < 10 ? ('0' + m) : m.toString();
+    d = d < 10 ? ('0' + d) : d.toString();
+    return Y + infix + m + infix + d;
+};
+const yymmdd = (timestamp, infix = '') => ymd(timestamp, infix, false);
+const yyyymmdd = (timestamp, infix = '-') => ymd(timestamp, infix, true);
+const ymdhms = (timestamp, infix = ' ') => {
+    const date = new Date(timestamp);
+    const Y = date.getUTCFullYear();
+    let m = date.getUTCMonth() + 1;
+    let d = date.getUTCDate();
+    let H = date.getUTCHours();
+    let M = date.getUTCMinutes();
+    let S = date.getUTCSeconds();
+    m = m < 10 ? ('0' + m) : m;
+    d = d < 10 ? ('0' + d) : d;
+    H = H < 10 ? ('0' + H) : H;
+    M = M < 10 ? ('0' + M) : M;
+    S = S < 10 ? ('0' + S) : S;
+    return Y + '-' + m + '-' + d + infix + H + ':' + M + ':' + S;
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout_safe(resolve, ms));
+const timeout = async (ms, promise) => {
+    let clear = () => { };
+    const expires = new Promise((resolve) => (clear = setTimeout_safe(resolve, ms)));
+    try {
+        return await Promise.race([promise, expires.then(() => {
+                throw new TimedOut();
+            })]);
+    }
+    finally {
+        clear(); // fixes https://github.com/ccxt/ccxt/issues/749
+    }
+};
+
+exports.TimedOut = TimedOut;
+exports.iso8601 = iso8601;
+exports.mdy = mdy;
+exports.microseconds = microseconds;
+exports.milliseconds = milliseconds;
+exports.now = now;
+exports.parse8601 = parse8601;
+exports.parseDate = parseDate;
+exports.rfc2616 = rfc2616;
+exports.seconds = seconds;
+exports.setTimeout_safe = setTimeout_safe;
+exports.sleep = sleep;
+exports.timeout = timeout;
+exports.uuidv1 = uuidv1;
+exports.ymd = ymd;
+exports.ymdhms = ymdhms;
+exports.yymmdd = yymmdd;
+exports.yyyymmdd = yyyymmdd;

package/dist/cjs/js/src/base/functions/totp.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../static_dependencies/scure-base/index.js');
+var sha1 = require('../../static_dependencies/noble-hashes/sha1.js');
+var crypto = require('./crypto.js');
+
+function totp(secret) {
+    const dec2hex = (s) => ((s < 15.5 ? '0' : '') + Math.round(s).toString(16));
+    const hex2dec = (s) => parseInt(s, 16);
+    const leftpad = (s, p) => (p + s).slice(-p.length); // both s and p are short strings
+    secret = secret.replace(' ', ''); // support 2fa-secrets with spaces like "4TDV WOGO" → "4TDVWOGO"
+    const epoch = Math.round(new Date().getTime() / 1000.0);
+    const time = leftpad(dec2hex(Math.floor(epoch / 30)), '0000000000000000');
+    const hmacRes = crypto.hmac(index.base16.decode(time), index.base32.decode(secret), sha1.sha1, 'hex');
+    const offset = hex2dec(hmacRes.substring(hmacRes.length - 1));
+    // eslint-disable-next-line
+    let otp = (hex2dec(hmacRes.substr(offset * 2, 8)) & hex2dec('7fffffff')) + '';
+    return otp.substring(otp.length - 6, otp.length);
+}
+
+exports["default"] = totp;
+exports.totp = totp;

package/dist/cjs/js/src/base/functions/type.js

@@ -0,0 +1,162 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/*  ------------------------------------------------------------------------ */
+const isNumber = Number.isFinite;
+const isInteger = Number.isInteger;
+const isArray = Array.isArray;
+const hasProps = (o) => ((o !== undefined) && (o !== null));
+const isString = (s) => (typeof s === 'string');
+const isObject = (o) => ((o !== null) && (typeof o === 'object'));
+const isRegExp = (o) => (o instanceof RegExp);
+const isDictionary = (o) => (isObject(o) && (Object.getPrototypeOf(o) === Object.prototype) && !isArray(o) && !isRegExp(o));
+const isStringCoercible = (x) => ((hasProps(x) && x.toString) || isNumber(x));
+/*  .............................................   */
+const prop = (o, k) => (isObject(o) && o[k] !== '' && o[k] !== null ? o[k] : undefined);
+const prop2 = (o, k1, k2) => (!isObject(o)
+    ? undefined
+    : (o[k1] !== undefined && o[k1] !== '' && o[k1] !== null
+        ? o[k1]
+        : (o[k2] !== '' && o[k2] !== null
+            ? o[k2]
+            : undefined)));
+const getValueFromKeysInArray = (object, array) => object[array.find((k) => prop(object, k) !== undefined)];
+/*  .............................................   */
+const asFloat = (x) => ((isNumber(x) || (isString(x) && x.length !== 0)) ? parseFloat(x) : NaN);
+const asInteger = (x) => ((isNumber(x) || (isString(x) && x.length !== 0)) ? Math.trunc(Number(x)) : NaN);
+/*  .............................................   */
+const safeFloat = (o, k, $default) => {
+    const n = asFloat(prop(o, k));
+    return isNumber(n) ? n : $default;
+};
+const safeInteger = (o, k, $default) => {
+    const n = asInteger(prop(o, k));
+    return isNumber(n) ? n : $default;
+};
+const safeIntegerProduct = (o, k, $factor, $default) => {
+    const n = asFloat(prop(o, k));
+    return isNumber(n) ? parseInt(n * $factor) : $default;
+};
+const safeTimestamp = (o, k, $default) => {
+    const n = asFloat(prop(o, k));
+    return isNumber(n) ? parseInt(n * 1000) : $default;
+};
+const safeValue = (o, k, $default) => {
+    const x = prop(o, k);
+    return hasProps(x) ? x : $default;
+};
+const safeString = (o, k, $default) => {
+    const x = prop(o, k);
+    return isStringCoercible(x) ? String(x) : $default;
+};
+const safeStringLower = (o, k, $default) => {
+    const x = prop(o, k);
+    return isStringCoercible(x) ? String(x).toLowerCase() : $default;
+};
+const safeStringUpper = (o, k, $default) => {
+    const x = prop(o, k);
+    return isStringCoercible(x) ? String(x).toUpperCase() : $default;
+};
+/*  .............................................   */
+const safeFloat2 = (o, k1, k2, $default) => {
+    const n = asFloat(prop2(o, k1, k2));
+    return isNumber(n) ? n : $default;
+};
+const safeInteger2 = (o, k1, k2, $default) => {
+    const n = asInteger(prop2(o, k1, k2));
+    return isNumber(n) ? n : $default;
+};
+const safeIntegerProduct2 = (o, k1, k2, $factor, $default) => {
+    const n = asInteger(prop2(o, k1, k2));
+    return isNumber(n) ? parseInt(n * $factor) : $default;
+};
+const safeTimestamp2 = (o, k1, k2, $default) => {
+    const n = asFloat(prop2(o, k1, k2));
+    return isNumber(n) ? parseInt(n * 1000) : $default;
+};
+const safeValue2 = (o, k1, k2, $default) => {
+    const x = prop2(o, k1, k2);
+    return hasProps(x) ? x : $default;
+};
+const safeString2 = (o, k1, k2, $default) => {
+    const x = prop2(o, k1, k2);
+    return isStringCoercible(x) ? String(x) : $default;
+};
+const safeStringLower2 = (o, k1, k2, $default) => {
+    const x = prop2(o, k1, k2);
+    return isStringCoercible(x) ? String(x).toLowerCase() : $default;
+};
+const safeStringUpper2 = (o, k1, k2, $default) => {
+    const x = prop2(o, k1, k2);
+    return isStringCoercible(x) ? String(x).toUpperCase() : $default;
+};
+const safeFloatN = (o, k, $default) => {
+    const n = asFloat(getValueFromKeysInArray(o, k));
+    return isNumber(n) ? n : $default;
+};
+const safeIntegerN = (o, k, $default) => {
+    const n = asInteger(getValueFromKeysInArray(o, k));
+    return isNumber(n) ? n : $default;
+};
+const safeIntegerProductN = (o, k, $factor, $default) => {
+    const n = asInteger(getValueFromKeysInArray(o, k));
+    return isNumber(n) ? parseInt(n * $factor) : $default;
+};
+const safeTimestampN = (o, k, $default) => {
+    const n = asFloat(getValueFromKeysInArray(o, k));
+    return isNumber(n) ? parseInt(n * 1000) : $default;
+};
+const safeValueN = (o, k, $default) => {
+    const x = getValueFromKeysInArray(o, k);
+    return hasProps(x) ? x : $default;
+};
+const safeStringN = (o, k, $default) => {
+    const x = getValueFromKeysInArray(o, k);
+    return isStringCoercible(x) ? String(x) : $default;
+};
+const safeStringLowerN = (o, k, $default) => {
+    const x = getValueFromKeysInArray(o, k);
+    return isStringCoercible(x) ? String(x).toLowerCase() : $default;
+};
+const safeStringUpperN = (o, k, $default) => {
+    const x = getValueFromKeysInArray(o, k);
+    return isStringCoercible(x) ? String(x).toUpperCase() : $default;
+};
+/*  ------------------------------------------------------------------------ */
+
+exports.asFloat = asFloat;
+exports.asInteger = asInteger;
+exports.hasProps = hasProps;
+exports.isArray = isArray;
+exports.isDictionary = isDictionary;
+exports.isInteger = isInteger;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.isStringCoercible = isStringCoercible;
+exports.prop = prop;
+exports.safeFloat = safeFloat;
+exports.safeFloat2 = safeFloat2;
+exports.safeFloatN = safeFloatN;
+exports.safeInteger = safeInteger;
+exports.safeInteger2 = safeInteger2;
+exports.safeIntegerN = safeIntegerN;
+exports.safeIntegerProduct = safeIntegerProduct;
+exports.safeIntegerProduct2 = safeIntegerProduct2;
+exports.safeIntegerProductN = safeIntegerProductN;
+exports.safeString = safeString;
+exports.safeString2 = safeString2;
+exports.safeStringLower = safeStringLower;
+exports.safeStringLower2 = safeStringLower2;
+exports.safeStringLowerN = safeStringLowerN;
+exports.safeStringN = safeStringN;
+exports.safeStringUpper = safeStringUpper;
+exports.safeStringUpper2 = safeStringUpper2;
+exports.safeStringUpperN = safeStringUpperN;
+exports.safeTimestamp = safeTimestamp;
+exports.safeTimestamp2 = safeTimestamp2;
+exports.safeTimestampN = safeTimestampN;
+exports.safeValue = safeValue;
+exports.safeValue2 = safeValue2;
+exports.safeValueN = safeValueN;

package/dist/cjs/js/src/base/functions.js

@@ -0,0 +1,157 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var platform = require('./functions/platform.js');
+var generic = require('./functions/generic.js');
+var string = require('./functions/string.js');
+var type = require('./functions/type.js');
+var number = require('./functions/number.js');
+var encode = require('./functions/encode.js');
+var crypto = require('./functions/crypto.js');
+var time = require('./functions/time.js');
+var throttle = require('./functions/throttle.js');
+var misc = require('./functions/misc.js');
+
+/*  ------------------------------------------------------------------------ */
+/*  ------------------------------------------------------------------------ */
+
+exports.isBrowser = platform.isBrowser;
+exports.isElectron = platform.isElectron;
+exports.isNode = platform.isNode;
+exports.isWebWorker = platform.isWebWorker;
+exports.isWindows = platform.isWindows;
+exports.arrayConcat = generic.arrayConcat;
+exports.clone = generic.clone;
+exports.deepExtend = generic.deepExtend;
+exports.extend = generic.extend;
+exports.filterBy = generic.filterBy;
+exports.flatten = generic.flatten;
+exports.groupBy = generic.groupBy;
+exports.inArray = generic.inArray;
+exports.index = generic.index;
+exports.indexBy = generic.indexBy;
+exports.isEmpty = generic.isEmpty;
+exports.keys = generic.keys;
+exports.keysort = generic.keysort;
+exports.merge = generic.merge;
+exports.omit = generic.omit;
+exports.ordered = generic.ordered;
+exports.pluck = generic.pluck;
+exports.sortBy = generic.sortBy;
+exports.sortBy2 = generic.sortBy2;
+exports.sum = generic.sum;
+exports.toArray = generic.toArray;
+exports.unique = generic.unique;
+exports.values = generic.values;
+exports.capitalize = string.capitalize;
+exports.strip = string.strip;
+exports.unCamelCase = string.unCamelCase;
+exports.uuid = string.uuid;
+exports.uuid16 = string.uuid16;
+exports.uuid22 = string.uuid22;
+exports.asFloat = type.asFloat;
+exports.asInteger = type.asInteger;
+exports.hasProps = type.hasProps;
+exports.isArray = type.isArray;
+exports.isDictionary = type.isDictionary;
+exports.isInteger = type.isInteger;
+exports.isNumber = type.isNumber;
+exports.isObject = type.isObject;
+exports.isString = type.isString;
+exports.isStringCoercible = type.isStringCoercible;
+exports.prop = type.prop;
+exports.safeFloat = type.safeFloat;
+exports.safeFloat2 = type.safeFloat2;
+exports.safeFloatN = type.safeFloatN;
+exports.safeInteger = type.safeInteger;
+exports.safeInteger2 = type.safeInteger2;
+exports.safeIntegerN = type.safeIntegerN;
+exports.safeIntegerProduct = type.safeIntegerProduct;
+exports.safeIntegerProduct2 = type.safeIntegerProduct2;
+exports.safeIntegerProductN = type.safeIntegerProductN;
+exports.safeString = type.safeString;
+exports.safeString2 = type.safeString2;
+exports.safeStringLower = type.safeStringLower;
+exports.safeStringLower2 = type.safeStringLower2;
+exports.safeStringLowerN = type.safeStringLowerN;
+exports.safeStringN = type.safeStringN;
+exports.safeStringUpper = type.safeStringUpper;
+exports.safeStringUpper2 = type.safeStringUpper2;
+exports.safeStringUpperN = type.safeStringUpperN;
+exports.safeTimestamp = type.safeTimestamp;
+exports.safeTimestamp2 = type.safeTimestamp2;
+exports.safeTimestampN = type.safeTimestampN;
+exports.safeValue = type.safeValue;
+exports.safeValue2 = type.safeValue2;
+exports.safeValueN = type.safeValueN;
+exports.DECIMAL_PLACES = number.DECIMAL_PLACES;
+exports.NO_PADDING = number.NO_PADDING;
+exports.PAD_WITH_ZERO = number.PAD_WITH_ZERO;
+exports.ROUND = number.ROUND;
+exports.ROUND_DOWN = number.ROUND_DOWN;
+exports.ROUND_UP = number.ROUND_UP;
+exports.SIGNIFICANT_DIGITS = number.SIGNIFICANT_DIGITS;
+exports.TICK_SIZE = number.TICK_SIZE;
+exports.TRUNCATE = number.TRUNCATE;
+exports.decimalToPrecision = number.decimalToPrecision;
+exports.numberToString = number.numberToString;
+exports.omitZero = number.omitZero;
+exports.precisionConstants = number.precisionConstants;
+exports.precisionFromString = number.precisionFromString;
+exports.truncate = number.truncate;
+exports.truncate_to_string = number.truncate_to_string;
+exports.base16ToBinary = encode.base16ToBinary;
+exports.base58ToBinary = encode.base58ToBinary;
+exports.base64ToBinary = encode.base64ToBinary;
+exports.base64ToString = encode.base64ToString;
+exports.binaryConcat = encode.binaryConcat;
+exports.binaryConcatArray = encode.binaryConcatArray;
+exports.binaryToBase16 = encode.binaryToBase16;
+exports.binaryToBase58 = encode.binaryToBase58;
+exports.binaryToBase64 = encode.binaryToBase64;
+exports.binaryToString = encode.binaryToString;
+exports.decode = encode.decode;
+exports.encode = encode.encode;
+exports.isJsonEncodedObject = encode.isJsonEncodedObject;
+exports.json = encode.json;
+exports.numberToBE = encode.numberToBE;
+exports.numberToLE = encode.numberToLE;
+exports.rawencode = encode.rawencode;
+exports.stringToBase64 = encode.stringToBase64;
+exports.stringToBinary = encode.stringToBinary;
+exports.urlencode = encode.urlencode;
+exports.urlencodeBase64 = encode.urlencodeBase64;
+exports.urlencodeNested = encode.urlencodeNested;
+exports.urlencodeWithArrayRepeat = encode.urlencodeWithArrayRepeat;
+exports.axolotl = crypto.axolotl;
+exports.crc32 = crypto.crc32;
+exports.ecdsa = crypto.ecdsa;
+exports.eddsa = crypto.eddsa;
+exports.hash = crypto.hash;
+exports.hmac = crypto.hmac;
+exports.TimedOut = time.TimedOut;
+exports.iso8601 = time.iso8601;
+exports.mdy = time.mdy;
+exports.microseconds = time.microseconds;
+exports.milliseconds = time.milliseconds;
+exports.now = time.now;
+exports.parse8601 = time.parse8601;
+exports.parseDate = time.parseDate;
+exports.rfc2616 = time.rfc2616;
+exports.seconds = time.seconds;
+exports.setTimeout_safe = time.setTimeout_safe;
+exports.sleep = time.sleep;
+exports.timeout = time.timeout;
+exports.uuidv1 = time.uuidv1;
+exports.ymd = time.ymd;
+exports.ymdhms = time.ymdhms;
+exports.yymmdd = time.yymmdd;
+exports.yyyymmdd = time.yyyymmdd;
+exports.Throttler = throttle.Throttler;
+exports.aggregate = misc.aggregate;
+exports.extractParams = misc.extractParams;
+exports.implodeParams = misc.implodeParams;
+exports.parseTimeframe = misc.parseTimeframe;
+exports.roundTimeframe = misc.roundTimeframe;
+exports.vwap = misc.vwap;