ccxt 4.2.11 → 4.2.13

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

@@ -0,0 +1,193 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var type = require('./type.js');
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+const keys = Object.keys; // eslint-disable-line padding-line-between-statements
+const values = (x) => ((!type.isArray(x)) ? Object.values(x) : x); // don't copy arrays if they're already arrays
+const index = (x) => new Set(values(x));
+const extend = (...args) => Object.assign({}, ...args); // NB: side-effect free
+const clone = (x) => (type.isArray(x) ? Array.from(x) : extend(x)); // clone arrays or objects
+// ----------------------------------------------------------------------------
+const ordered = (x) => x; // a stub to keep assoc keys in order (in JS it does nothing, it's mostly for Python)
+const unique = (x) => Array.from(index(x));
+const arrayConcat = (a, b) => a.concat(b);
+// ------------------------------------------------------------------------
+const inArray = (needle, haystack) => haystack.includes(needle);
+const toArray = (object) => Object.values(object);
+const isEmpty = (object) => {
+    if (!object) {
+        return true;
+    }
+    return (Array.isArray(object) ? object : Object.keys(object)).length < 1;
+};
+const keysort = (x, out = {}) => {
+    for (const k of keys(x).sort()) {
+        out[k] = x[k];
+    }
+    return out;
+};
+/*
+    Accepts a map/array of objects and a key name to be used as an index:
+    array = [
+        { someKey: 'value1', anotherKey: 'anotherValue1' },
+        { someKey: 'value2', anotherKey: 'anotherValue2' },
+        { someKey: 'value3', anotherKey: 'anotherValue3' },
+    ]
+    key = 'someKey'
+    Returns a map:
+    {
+        value1: { someKey: 'value1', anotherKey: 'anotherValue1' },
+        value2: { someKey: 'value2', anotherKey: 'anotherValue2' },
+        value3: { someKey: 'value3', anotherKey: 'anotherValue3' },
+    }
+*/
+const groupBy = (x, k, out = {}) => {
+    for (const v of values(x)) {
+        if (k in v) {
+            const p = v[k];
+            out[p] = out[p] || [];
+            out[p].push(v);
+        }
+    }
+    return out;
+};
+const indexBy = (x, k, out = {}) => {
+    for (const v of values(x)) {
+        if (k in v) {
+            out[v[k]] = v;
+        }
+    }
+    return out;
+};
+const filterBy = (x, k, value = undefined, out = []) => {
+    for (const v of values(x)) {
+        if (v[k] === value) {
+            out.push(v);
+        }
+    }
+    return out;
+};
+const sortBy = (array, key, descending = false, defaultValue = 0, direction = descending ? -1 : 1) => array.sort((a, b) => {
+    const first = (key in a) ? a[key] : defaultValue;
+    const second = (key in b) ? b[key] : defaultValue;
+    if (first < second) {
+        return -direction;
+    }
+    else if (first > second) {
+        return direction;
+    }
+    else {
+        return 0;
+    }
+});
+const sortBy2 = (array, key1, key2, descending = false, direction = descending ? -1 : 1) => array.sort((a, b) => {
+    if (a[key1] < b[key1]) {
+        return -direction;
+    }
+    else if (a[key1] > b[key1]) {
+        return direction;
+    }
+    else {
+        if (a[key2] < b[key2]) {
+            return -direction;
+        }
+        else if (a[key2] > b[key2]) {
+            return direction;
+        }
+        else {
+            return 0;
+        }
+    }
+});
+const flatten = function flatten(x, out = []) {
+    for (const v of x) {
+        if (type.isArray(v)) {
+            flatten(v, out);
+        }
+        else {
+            out.push(v);
+        }
+    }
+    return out;
+};
+const pluck = (x, k) => values(x).filter((v) => k in v).map((v) => v[k]);
+const omit = (x, ...args) => {
+    if (!Array.isArray(x)) {
+        const out = clone(x);
+        for (const k of args) {
+            if (type.isArray(k)) { // omit (x, ['a', 'b'])
+                for (const kk of k) {
+                    delete out[kk];
+                }
+            }
+            else {
+                delete out[k]; // omit (x, 'a', 'b')
+            }
+        }
+        return out;
+    }
+    return x;
+};
+const sum = (...xs) => {
+    const ns = xs.filter(type.isNumber); // leave only numbers
+    return (ns.length > 0) ? ns.reduce((a, b) => a + b, 0) : undefined;
+};
+const deepExtend = function deepExtend(...xs) {
+    let out = undefined;
+    for (const x of xs) {
+        if (type.isDictionary(x)) {
+            if (!type.isDictionary(out)) {
+                out = {};
+            }
+            for (const k in x) {
+                out[k] = deepExtend(out[k], x[k]);
+            }
+        }
+        else {
+            out = x;
+        }
+    }
+    return out;
+};
+const merge = (target, ...args) => {
+    // doesn't overwrite defined keys with undefined
+    const overwrite = {};
+    const merged = Object.assign({}, ...args);
+    const keys = Object.keys(merged);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (target[key] === undefined) {
+            overwrite[key] = merged[key];
+        }
+    }
+    // eslint-disable-next-line
+    return Object.assign({}, target, overwrite);
+};
+
+exports.arrayConcat = arrayConcat;
+exports.clone = clone;
+exports.deepExtend = deepExtend;
+exports.extend = extend;
+exports.filterBy = filterBy;
+exports.flatten = flatten;
+exports.groupBy = groupBy;
+exports.inArray = inArray;
+exports.index = index;
+exports.indexBy = indexBy;
+exports.isEmpty = isEmpty;
+exports.keys = keys;
+exports.keysort = keysort;
+exports.merge = merge;
+exports.omit = omit;
+exports.ordered = ordered;
+exports.pluck = pluck;
+exports.sortBy = sortBy;
+exports.sortBy2 = sortBy2;
+exports.sum = sum;
+exports.toArray = toArray;
+exports.unique = unique;
+exports.values = values;

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

@@ -0,0 +1,96 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var number = require('./number.js');
+var type = require('./type.js');
+var errors = require('../errors.js');
+
+//-------------------------------------------------------------------------
+// converts timeframe to seconds
+const parseTimeframe = (timeframe) => {
+    const amount = type.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 errors.NotSupported('timeframe unit ' + unit + ' is not supported');
+    }
+    return amount * scale;
+};
+const roundTimeframe = (timeframe, timestamp, direction = number.ROUND_DOWN) => {
+    const ms = parseTimeframe(timeframe) * 1000;
+    // Get offset based on timeframe in milliseconds
+    const offset = timestamp % ms;
+    return timestamp - offset + ((direction === number.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;
+        }
+    }
+    return Object.keys(result).map((price) => [parseFloat(price), parseFloat(result[price])]);
+}
+/*  ------------------------------------------------------------------------ */
+
+exports.aggregate = aggregate;
+exports.extractParams = extractParams;
+exports.implodeParams = implodeParams;
+exports.parseTimeframe = parseTimeframe;
+exports.roundTimeframe = roundTimeframe;
+exports.vwap = vwap;

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

@@ -0,0 +1,297 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// ------------------------------------------------------------------------
+//
+//  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,
+};
+/*  ------------------------------------------------------------------------ */
+// 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) {
+        const numStr = str.replace(/\de/, '');
+        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) => {
+    if (countingMode === TICK_SIZE) {
+        if (typeof numPrecisionDigits === 'string') {
+            numPrecisionDigits = parseFloat(numPrecisionDigits);
+        }
+        if (numPrecisionDigits <= 0) {
+            throw new Error('TICK_SIZE cant be used with negative or zero numPrecisionDigits');
+        }
+    }
+    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);
+        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;
+                    }
+                }
+            }
+            else if (roundingMode === TRUNCATE) {
+                x = x - missing;
+            }
+        }
+        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) {
+    if (stringNumber === undefined || stringNumber === '') {
+        return undefined;
+    }
+    if (parseFloat(stringNumber) === 0) {
+        return undefined;
+    }
+    return stringNumber;
+}
+/*  ------------------------------------------------------------------------ */
+
+exports.DECIMAL_PLACES = DECIMAL_PLACES;
+exports.NO_PADDING = NO_PADDING;
+exports.PAD_WITH_ZERO = PAD_WITH_ZERO;
+exports.ROUND = ROUND;
+exports.ROUND_DOWN = ROUND_DOWN;
+exports.ROUND_UP = ROUND_UP;
+exports.SIGNIFICANT_DIGITS = SIGNIFICANT_DIGITS;
+exports.TICK_SIZE = TICK_SIZE;
+exports.TRUNCATE = TRUNCATE;
+exports.decimalToPrecision = decimalToPrecision;
+exports.numberToString = numberToString;
+exports.omitZero = omitZero;
+exports.precisionConstants = precisionConstants;
+exports.precisionFromString = precisionFromString;
+exports.truncate = truncate;
+exports.truncate_to_string = truncate_to_string;

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

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// @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 isNode = !(isBrowser || isWebWorker);
+
+exports.isBrowser = isBrowser;
+exports.isElectron = isElectron;
+exports.isNode = isNode;
+exports.isWebWorker = isWebWorker;
+exports.isWindows = isWindows;

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

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var JSEncrypt = require('../../static_dependencies/jsencrypt/JSEncrypt.js');
+var index = require('../../static_dependencies/scure-base/index.js');
+var encode = require('./encode.js');
+var crypto = require('./crypto.js');
+
+function rsa(request, secret, hash) {
+    const RSA = new JSEncrypt.JSEncrypt();
+    const digester = (input) => index.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) {
+    const alg = (isRSA ? 'RS' : 'HS') + (hash.outputLen * 8);
+    const encodedHeader = encode.urlencodeBase64(encode.stringToBase64(JSON.stringify({ 'alg': alg, 'typ': 'JWT' })));
+    const encodedData = encode.urlencodeBase64(encode.stringToBase64(JSON.stringify(request)));
+    const token = [encodedHeader, encodedData].join('.');
+    const algoType = alg.slice(0, 2);
+    let signature = undefined;
+    if (algoType === 'HS') {
+        signature = encode.urlencodeBase64(crypto.hmac(token, secret, hash, 'base64'));
+    }
+    else if (algoType === 'RS') {
+        signature = encode.urlencodeBase64(rsa(token, index.utf8.encode(secret), hash));
+    }
+    return [token, signature].join('.');
+}
+
+exports.jwt = jwt;
+exports.rsa = rsa;