ccxt-ir 4.10.0 → 4.11.0

package/js/src/src/base/functions/misc.d.ts

@@ -0,0 +1,9 @@
+import { Dictionary, Num } from '../types.js';
+declare const parseTimeframe: (timeframe: string) => number;
+declare const roundTimeframe: (timeframe: string, timestamp: number, direction?: number) => number;
+declare const extractParams: (string: string) => string[];
+declare const implodeParams: (string: string, params: Dictionary<any> | any[]) => string;
+declare function vwap(baseVolume: number, quoteVolume: number): Num;
+declare function aggregate(bidasks: any): number[][];
+declare function selfIsDefined(): boolean;
+export { aggregate, parseTimeframe, roundTimeframe, implodeParams, extractParams, vwap, selfIsDefined };

package/js/src/src/base/functions/misc.js

@@ -0,0 +1,101 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+import { ROUND_UP, ROUND_DOWN } from './number.js';
+import { asFloat } from './type.js';
+import { NotSupported } from '../errors.js';
+//-------------------------------------------------------------------------
+// converts timeframe to seconds
+const parseTimeframe = (timeframe) => {
+    const amount = asFloat(timeframe.slice(0, -1));
+    const unit = timeframe.slice(-1);
+    let scale = undefined;
+    if (unit === 'y') {
+        scale = 60 * 60 * 24 * 365;
+    }
+    else if (unit === 'M') {
+        scale = 60 * 60 * 24 * 30;
+    }
+    else if (unit === 'w') {
+        scale = 60 * 60 * 24 * 7;
+    }
+    else if (unit === 'd') {
+        scale = 60 * 60 * 24;
+    }
+    else if (unit === 'h') {
+        scale = 60 * 60;
+    }
+    else if (unit === 'm') {
+        scale = 60;
+    }
+    else if (unit === 's') {
+        scale = 1;
+    }
+    else {
+        throw new NotSupported('timeframe unit ' + unit + ' is not supported');
+    }
+    return amount * scale;
+};
+const roundTimeframe = (timeframe, timestamp, direction = ROUND_DOWN) => {
+    const ms = parseTimeframe(timeframe) * 1000;
+    // Get offset based on timeframe in milliseconds
+    const offset = timestamp % ms;
+    return timestamp - offset + ((direction === ROUND_UP) ? ms : 0);
+};
+const extractParams = (string) => {
+    /**
+     * @ignore
+     * @method
+     * @param string usually a url path
+     * @returns {[string]} all substrings surrounded by {} from parameter string
+     */
+    const re = /{([\w-]+)}/g;
+    const matches = [];
+    let match = re.exec(string);
+    while (match) {
+        matches.push(match[1]);
+        match = re.exec(string);
+    }
+    return matches;
+};
+const implodeParams = (string, params) => {
+    if (!Array.isArray(params)) {
+        const keys = Object.keys(params);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (!Array.isArray(params[key])) {
+                string = string.replace('{' + key + '}', params[key]);
+            }
+        }
+    }
+    return string;
+};
+function vwap(baseVolume, quoteVolume) {
+    return ((baseVolume !== undefined) && (quoteVolume !== undefined) && (baseVolume > 0)) ? (quoteVolume / baseVolume) : undefined;
+}
+/*  ------------------------------------------------------------------------ */
+function aggregate(bidasks) {
+    const result = {};
+    for (let i = 0; i < bidasks.length; i++) {
+        const [price, volume] = bidasks[i];
+        if (volume > 0) {
+            result[price] = (result[price] || 0) + volume; // TODO: Element implicitly has an 'any' type because expression of type 'any' can't be used to index type '{}'.ts(7053)
+        }
+    }
+    return Object.keys(result).map((price) => [parseFloat(price), parseFloat(result[price])]); // TODO: Element implicitly has an 'any' type because expression of type 'string' can't be used to index type '{}',   No index signature with a parameter of type 'string' was found on type '{}'.ts(7053)
+}
+function selfIsDefined() {
+    let selfIsDefined = false;
+    try {
+        selfIsDefined = self !== undefined;
+    }
+    catch (e) {
+        selfIsDefined = false;
+    }
+    return selfIsDefined;
+}
+export { aggregate, parseTimeframe, roundTimeframe, implodeParams, extractParams, vwap, selfIsDefined };
+/*  ------------------------------------------------------------------------ */

package/js/src/src/base/functions/number.d.ts

@@ -0,0 +1,27 @@
+declare const TRUNCATE = 0;
+declare const ROUND = 1;
+declare const ROUND_UP = 2;
+declare const ROUND_DOWN = 3;
+declare const DECIMAL_PLACES = 2;
+declare const SIGNIFICANT_DIGITS = 3;
+declare const TICK_SIZE = 4;
+declare const NO_PADDING = 5;
+declare const PAD_WITH_ZERO = 6;
+declare const precisionConstants: {
+    ROUND: number;
+    TRUNCATE: number;
+    ROUND_UP: number;
+    ROUND_DOWN: number;
+    DECIMAL_PLACES: number;
+    SIGNIFICANT_DIGITS: number;
+    TICK_SIZE: number;
+    NO_PADDING: number;
+    PAD_WITH_ZERO: number;
+};
+declare function numberToString(x: any): string | undefined;
+declare const truncate_to_string: (num: number | string, precision?: number) => string;
+declare const truncate: (num: number | string, precision?: number) => number;
+declare function precisionFromString(str: string): number;
+declare const decimalToPrecision: (x: string, roundingMode: number, numPrecisionDigits: any, countingMode?: number, paddingMode?: number) => string;
+declare function omitZero(stringNumber: string): string;
+export { numberToString, precisionFromString, decimalToPrecision, truncate_to_string, truncate, omitZero, precisionConstants, ROUND, TRUNCATE, ROUND_UP, ROUND_DOWN, DECIMAL_PLACES, SIGNIFICANT_DIGITS, TICK_SIZE, NO_PADDING, PAD_WITH_ZERO, };

package/js/src/src/base/functions/number.js

@@ -0,0 +1,313 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+// ------------------------------------------------------------------------
+//
+//  NB: initially, I used objects for options passing:
+//
+//          decimalToPrecision ('123.456', { digits: 2, round: true, afterPoint: true })
+//
+//  ...but it turns out it's hard to port that across different languages and it is also
+//     probably has a performance penalty -- while it's a performance critical code! So
+//     I switched to using named constants instead, as it is actually more readable and
+//     succinct, and surely doesn't come with any inherent performance downside:
+//
+//          decimalToPrecision ('123.456', ROUND, 2, DECIMAL_PLACES)
+const TRUNCATE = 0; // rounding mode
+const ROUND = 1;
+const ROUND_UP = 2;
+const ROUND_DOWN = 3;
+const DECIMAL_PLACES = 2; // digits counting mode
+const SIGNIFICANT_DIGITS = 3;
+const TICK_SIZE = 4;
+const NO_PADDING = 5; // zero-padding mode
+const PAD_WITH_ZERO = 6;
+const precisionConstants = {
+    ROUND,
+    TRUNCATE,
+    ROUND_UP,
+    ROUND_DOWN,
+    DECIMAL_PLACES,
+    SIGNIFICANT_DIGITS,
+    TICK_SIZE,
+    NO_PADDING,
+    PAD_WITH_ZERO,
+};
+const assert = (x, y) => { if (!x)
+    throw new Error(y || 'assertion failed'); };
+/*  ------------------------------------------------------------------------ */
+// See https://stackoverflow.com/questions/1685680/how-to-avoid-scientific-notation-for-large-numbers-in-javascript for discussion
+function numberToString(x) {
+    if (x === undefined)
+        return undefined;
+    if (typeof x !== 'number')
+        return x.toString();
+    const s = x.toString();
+    if (Math.abs(x) < 1.0) {
+        const n_e = s.split('e-');
+        const n = n_e[0].replace('.', '');
+        const e = parseInt(n_e[1]);
+        const neg = (s[0] === '-');
+        if (e) {
+            x = (neg ? '-' : '') + '0.' + (new Array(e)).join('0') + n.substring(neg);
+            return x;
+        }
+    }
+    else {
+        const parts = s.split('e');
+        if (parts[1]) {
+            let e = parseInt(parts[1]);
+            const m = parts[0].split('.');
+            let part = '';
+            if (m[1]) {
+                e -= m[1].length;
+                part = m[1];
+            }
+            return m[0] + part + (new Array(e + 1)).join('0');
+        }
+    }
+    return s;
+}
+//-----------------------------------------------------------------------------
+// expects non-scientific notation
+const truncate_regExpCache = [];
+const truncate_to_string = (num, precision = 0) => {
+    num = numberToString(num);
+    if (precision > 0) {
+        const re = truncate_regExpCache[precision] || (truncate_regExpCache[precision] = new RegExp('([-]*\\d+\\.\\d{' + precision + '})(\\d)'));
+        const [, result] = num.toString().match(re) || [null, num];
+        return result.toString();
+    }
+    return parseInt(num).toString();
+};
+const truncate = (num, precision = 0) => parseFloat(truncate_to_string(num, precision));
+function precisionFromString(str) {
+    // support string formats like '1e-4'
+    if (str.indexOf('e') > -1 || str.indexOf('E') > -1) {
+        const numStr = str.replace(/\d\.?\d*[eE]/, '');
+        return parseInt(numStr) * -1;
+    }
+    // support integer formats (without dot) like '1', '10' etc [Note: bug in decimalToPrecision, so this should not be used atm]
+    // if (str.indexOf ('.') === -1) {
+    //     return str.length * -1
+    // }
+    // default strings like '0.0001'
+    const split = str.replace(/0+$/g, '').split('.');
+    return (split.length > 1) ? (split[1].length) : 0;
+}
+/*  ------------------------------------------------------------------------ */
+const decimalToPrecision = (x, roundingMode, numPrecisionDigits, countingMode = DECIMAL_PLACES, paddingMode = NO_PADDING) => {
+    return _decimalToPrecision(x, roundingMode, numPrecisionDigits, countingMode, paddingMode);
+};
+const _decimalToPrecision = (x, roundingMode, numPrecisionDigits, countingMode = DECIMAL_PLACES, paddingMode = NO_PADDING) => {
+    assert(numPrecisionDigits !== undefined, 'numPrecisionDigits should not be undefined');
+    if (typeof numPrecisionDigits === 'string') {
+        numPrecisionDigits = parseFloat(numPrecisionDigits);
+    }
+    assert(Number.isFinite(numPrecisionDigits), 'numPrecisionDigits has an invalid number');
+    if (countingMode === TICK_SIZE) {
+        assert(numPrecisionDigits > 0, 'negative or zero numPrecisionDigits can not be used with TICK_SIZE precisionMode');
+    }
+    else {
+        assert(Number.isInteger(numPrecisionDigits), 'numPrecisionDigits must be an integer with DECIMAL_PLACES or SIGNIFICANT_DIGITS precisionMode');
+    }
+    assert((roundingMode === ROUND) || (roundingMode === TRUNCATE), 'invalid roundingMode provided');
+    assert(countingMode === DECIMAL_PLACES || countingMode === SIGNIFICANT_DIGITS || countingMode === TICK_SIZE, 'invalid countingMode provided');
+    assert(paddingMode === NO_PADDING || paddingMode === PAD_WITH_ZERO, 'invalid paddingMode provided');
+    // end of checks
+    if (numPrecisionDigits < 0) {
+        const toNearest = Math.pow(10, -numPrecisionDigits);
+        if (roundingMode === ROUND) {
+            return (toNearest * _decimalToPrecision(x / toNearest, roundingMode, 0, countingMode, paddingMode)).toString();
+        }
+        if (roundingMode === TRUNCATE) {
+            return (x - (x % toNearest)).toString();
+        }
+    }
+    /*  handle tick size */
+    if (countingMode === TICK_SIZE) {
+        const precisionDigitsString = _decimalToPrecision(numPrecisionDigits, ROUND, 22, DECIMAL_PLACES, NO_PADDING);
+        const newNumPrecisionDigits = precisionFromString(precisionDigitsString);
+        if (roundingMode === TRUNCATE) {
+            // First, truncate the string to avoid floating-point precision issues
+            const xStr = numberToString(x);
+            const truncatedX = truncate_to_string(xStr, Math.max(0, newNumPrecisionDigits));
+            const xNum = Number(truncatedX);
+            const scale = Math.pow(10, newNumPrecisionDigits);
+            const xScaled = Math.round(xNum * scale);
+            const tickScaled = Math.round(numPrecisionDigits * scale);
+            const ticks = Math.trunc(xScaled / tickScaled);
+            x = (ticks * tickScaled) / scale;
+            if (paddingMode === NO_PADDING) {
+                return String(Number(x.toFixed(newNumPrecisionDigits)));
+            }
+            return _decimalToPrecision(x, ROUND, newNumPrecisionDigits, DECIMAL_PLACES, paddingMode);
+        }
+        let missing = x % numPrecisionDigits;
+        // See: https://github.com/ccxt/ccxt/pull/6486
+        missing = Number(_decimalToPrecision(missing, ROUND, 8, DECIMAL_PLACES, NO_PADDING));
+        const fpError = _decimalToPrecision(missing / numPrecisionDigits, ROUND, Math.max(newNumPrecisionDigits, 8), DECIMAL_PLACES, NO_PADDING);
+        if (precisionFromString(fpError) !== 0) {
+            if (roundingMode === ROUND) {
+                if (x > 0) {
+                    if (missing >= numPrecisionDigits / 2) {
+                        x = x - missing + numPrecisionDigits;
+                    }
+                    else {
+                        x = x - missing;
+                    }
+                }
+                else {
+                    if (missing >= numPrecisionDigits / 2) {
+                        x = Number(x) - missing;
+                    }
+                    else {
+                        x = Number(x) - missing - numPrecisionDigits;
+                    }
+                }
+            }
+        }
+        return _decimalToPrecision(x, ROUND, newNumPrecisionDigits, DECIMAL_PLACES, paddingMode);
+    }
+    /*  Convert to a string (if needed), skip leading minus sign (if any)   */
+    const str = numberToString(x);
+    const isNegative = str[0] === '-';
+    const strStart = isNegative ? 1 : 0;
+    const strEnd = str.length;
+    /*  Find the dot position in the source buffer   */
+    for (var strDot = 0; strDot < strEnd; strDot++) {
+        if (str[strDot] === '.')
+            break;
+    }
+    const hasDot = strDot < str.length;
+    /*  Char code constants         */
+    const MINUS = 45;
+    const DOT = 46;
+    const ZERO = 48;
+    const ONE = (ZERO + 1);
+    const FIVE = (ZERO + 5);
+    const NINE = (ZERO + 9);
+    /*  For -123.4567 the `chars` array will hold 01234567 (leading zero is reserved for rounding cases when 099 → 100)    */
+    const chars = new Uint8Array((strEnd - strStart) + (hasDot ? 0 : 1));
+    chars[0] = ZERO;
+    /*  Validate & copy digits, determine certain locations in the resulting buffer  */
+    let afterDot = chars.length;
+    let digitsStart = -1; // significant digits
+    let digitsEnd = -1;
+    for (var i = 1, j = strStart; j < strEnd; j++, i++) {
+        const c = str.charCodeAt(j);
+        if (c === DOT) {
+            afterDot = i--;
+        }
+        else if ((c < ZERO) || (c > NINE)) {
+            throw new Error(`${str}: invalid number (contains an illegal character '${str[i - 1]}')`);
+        }
+        else {
+            chars[i] = c;
+            if ((c !== ZERO) && (digitsStart < 0))
+                digitsStart = i;
+        }
+    }
+    if (digitsStart < 0)
+        digitsStart = 1;
+    /*  Determine the range to cut  */
+    let precisionStart = (countingMode === DECIMAL_PLACES) ? afterDot // 0.(0)001234567
+        : digitsStart; // 0.00(1)234567
+    let precisionEnd = precisionStart
+        + numPrecisionDigits;
+    /*  Reset the last significant digit index, as it will change during the rounding/truncation.   */
+    digitsEnd = -1;
+    // Perform rounding/truncation per digit, from digitsEnd to digitsStart, by using the following
+    //  algorithm (rounding 999 → 1000, as an example):
+    //
+    //      step  =          i=3      i=2      i=1      i=0
+    //
+    //      chars =         0999     0999     0900     1000
+    //      memo  =         ---0     --1-     -1--     0---
+    let allZeros = true;
+    let signNeeded = isNegative;
+    for (let i = chars.length - 1, memo = 0; i >= 0; i--) {
+        let c = chars[i];
+        if (i !== 0) {
+            c += memo;
+            if (i >= (precisionStart + numPrecisionDigits)) {
+                const ceil = (roundingMode === ROUND)
+                    && (c >= FIVE)
+                    && !((c === FIVE) && memo); // prevents rounding of 1.45 to 2
+                c = ceil ? (NINE + 1) : ZERO;
+            }
+            if (c > NINE) {
+                c = ZERO;
+                memo = 1;
+            }
+            else
+                memo = 0;
+        }
+        else if (memo)
+            c = ONE; // leading extra digit (0900 → 1000)
+        chars[i] = c;
+        if (c !== ZERO) {
+            allZeros = false;
+            digitsStart = i;
+            digitsEnd = (digitsEnd < 0) ? (i + 1) : digitsEnd;
+        }
+    }
+    /*  Update the precision range, as `digitsStart` may have changed... & the need for a negative sign if it is only 0    */
+    if (countingMode === SIGNIFICANT_DIGITS) {
+        precisionStart = digitsStart;
+        precisionEnd = precisionStart + numPrecisionDigits;
+    }
+    if (allZeros) {
+        signNeeded = false;
+    }
+    /*  Determine the input character range     */
+    const readStart = ((digitsStart >= afterDot) || allZeros) ? (afterDot - 1) : digitsStart; // 0.000(1)234  ----> (0).0001234
+    const readEnd = (digitsEnd < afterDot) ? (afterDot) : digitsEnd; // 12(3)000     ----> 123000( )
+    /*  Compute various sub-ranges       */
+    const nSign = (signNeeded ? 1 : 0); // (-)123.456
+    const nBeforeDot = (nSign + (afterDot - readStart)); // (-123).456
+    const nAfterDot = Math.max(readEnd - afterDot, 0); // -123.(456)
+    const actualLength = (readEnd - readStart); // -(123.456)
+    const desiredLength = (paddingMode === NO_PADDING)
+        ? (actualLength) // -(123.456)
+        : (precisionEnd - readStart); // -(123.456    )
+    const pad = Math.max(desiredLength - actualLength, 0); //  -123.456(    )
+    const padStart = (nBeforeDot + 1 + nAfterDot); //  -123.456( )
+    const padEnd = (padStart + pad); //  -123.456     ( )
+    const isInteger = (nAfterDot + pad) === 0; //  -123
+    /*  Fill the output buffer with characters    */
+    const out = new Uint8Array(nBeforeDot + (isInteger ? 0 : 1) + nAfterDot + pad);
+    // ------------------------------------------------------------------------------------------ // ---------------------
+    if (signNeeded)
+        out[0] = MINUS; // -     minus sign
+    for (i = nSign, j = readStart; i < nBeforeDot; i++, j++)
+        out[i] = chars[j]; // 123   before dot
+    if (!isInteger)
+        out[nBeforeDot] = DOT; // .     dot
+    for (i = nBeforeDot + 1, j = afterDot; i < padStart; i++, j++)
+        out[i] = chars[j]; // 456   after dot
+    for (i = padStart; i < padEnd; i++)
+        out[i] = ZERO; // 000   padding
+    /*  Build a string from the output buffer     */
+    return String.fromCharCode(...out);
+};
+function omitZero(stringNumber) {
+    try {
+        if (stringNumber === undefined || stringNumber === '') {
+            return undefined;
+        }
+        if (parseFloat(stringNumber) === 0) {
+            return undefined;
+        }
+        return stringNumber;
+    }
+    catch (e) {
+        return stringNumber;
+    }
+}
+/*  ------------------------------------------------------------------------ */
+export { numberToString, precisionFromString, decimalToPrecision, truncate_to_string, truncate, omitZero, precisionConstants, ROUND, TRUNCATE, ROUND_UP, ROUND_DOWN, DECIMAL_PLACES, SIGNIFICANT_DIGITS, TICK_SIZE, NO_PADDING, PAD_WITH_ZERO, };
+/*  ------------------------------------------------------------------------ */

package/js/src/src/base/functions/platform.d.ts

@@ -0,0 +1,7 @@
+declare const isBrowser: boolean;
+declare const isElectron: boolean;
+declare const isWebWorker: boolean;
+declare const isWindows: boolean;
+declare const isDeno: boolean;
+declare const isNode: boolean;
+export { isBrowser, isElectron, isWebWorker, isNode, isDeno, isWindows, };

package/js/src/src/base/functions/platform.js

@@ -0,0 +1,27 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+// @ts-nocheck
+// ----------------------------------------------------------------------------
+// There's been a lot of messing with this code...
+// The problem is to satisfy the following requirements:
+// - properly detect isNode == true on server side and isNode == false in the browser (on client side)
+// - make sure create-react-app, react-starter-kit and other react frameworks work
+// - make sure it does not break the browserified version (when linked into a html from a cdn)
+// - make sure it does not break the webpacking and babel-transpiled scripts
+// - make sure it works in Electron
+// - make sure it works with Angular.js
+// - make sure it does not break other possible usage scenarios
+const isBrowser = typeof window !== 'undefined';
+const isElectron = typeof process !== 'undefined' &&
+    typeof process.versions !== 'undefined' &&
+    typeof process.versions.electron !== 'undefined';
+const isWebWorker = typeof WorkerGlobalScope !== 'undefined' && (self instanceof WorkerGlobalScope);
+const isWindows = typeof process !== 'undefined' && process.platform === "win32";
+const isDeno = typeof Deno !== 'undefined';
+const isNode = !(isBrowser || isWebWorker || isDeno);
+// ----------------------------------------------------------------------------
+export { isBrowser, isElectron, isWebWorker, isNode, isDeno, isWindows, };

package/js/src/src/base/functions/rsa.d.ts

@@ -0,0 +1,5 @@
+import { CHash } from '../../static_dependencies/noble-hashes/utils.js';
+import { Dictionary } from "../types.js";
+declare function rsa(request: string, secret: string, hash: CHash): string;
+declare function jwt(request: Dictionary<any>, secret: Uint8Array, hash: CHash, isRSA?: boolean, opts?: Dictionary<any>): string;
+export { rsa, jwt };

package/js/src/src/base/functions/rsa.js

@@ -0,0 +1,49 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+import { JSEncrypt } from "../../static_dependencies/jsencrypt/JSEncrypt.js";
+import { base16, utf8 } from '../../static_dependencies/scure-base/index.js';
+import { urlencodeBase64, base16ToBinary, base64ToBinary } from './encode.js';
+import { hmac } from './crypto.js';
+import { P256 } from '../../static_dependencies/noble-curves/p256.js';
+import { ecdsa } from '../../base/functions/crypto.js';
+function rsa(request, secret, hash) {
+    const RSA = new JSEncrypt();
+    const digester = (input) => base16.encode(hash(input));
+    RSA.setPrivateKey(secret);
+    const name = (hash.create()).constructor.name.toLowerCase();
+    return RSA.sign(request, digester, name);
+}
+function jwt(request, secret, hash, isRSA = false, opts = {}) {
+    let alg = (isRSA ? 'RS' : 'HS') + (hash.outputLen * 8);
+    if (opts['alg']) {
+        alg = opts['alg'].toUpperCase();
+    }
+    const header = Object.assign({ 'alg': alg, 'typ': 'JWT' }, opts);
+    if (header['iat'] !== undefined) {
+        request['iat'] = header['iat'];
+        delete header['iat'];
+    }
+    const encodedHeader = urlencodeBase64(JSON.stringify(header));
+    const encodedData = urlencodeBase64(JSON.stringify(request));
+    const token = [encodedHeader, encodedData].join('.');
+    const algoType = alg.slice(0, 2);
+    let signature = undefined;
+    if (algoType === 'HS') {
+        signature = urlencodeBase64(hmac(token, secret, hash, 'binary'));
+    }
+    else if (isRSA || algoType === 'RS') {
+        signature = urlencodeBase64(base64ToBinary(rsa(token, utf8.encode(secret), hash)));
+    }
+    else if (algoType === 'ES') {
+        const signedHash = ecdsa(token, utf8.encode(secret), P256, hash);
+        const r = signedHash.r.padStart(64, '0');
+        const s = signedHash.s.padStart(64, '0');
+        signature = urlencodeBase64(base16ToBinary(r + s));
+    }
+    return [token, signature].join('.');
+}
+export { rsa, jwt };

package/js/src/src/base/functions/string.d.ts

@@ -0,0 +1,7 @@
+declare const unCamelCase: (s: string) => string;
+declare const capitalize: (s: string) => string;
+declare const strip: (s: string) => string;
+declare const uuid: (a?: any) => string;
+declare const uuid16: (a?: any) => string;
+declare const uuid22: (a?: any) => string;
+export { uuid, uuid16, uuid22, unCamelCase, capitalize, strip, };

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

@@ -0,0 +1,44 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+// ----------------------------------------------------------------------------
+// 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);
+};
+export { uuid, uuid16, uuid22, unCamelCase, capitalize, strip, };

package/js/src/src/base/functions/throttle.d.ts

@@ -0,0 +1,6 @@
+declare class Throttler {
+    constructor(config: any);
+    loop(): Promise<void>;
+    throttle(cost?: any): Promise<unknown>;
+}
+export { Throttler, };