ccxt-look 1.81.50

package/js/base/functions/number.js

@@ -0,0 +1,329 @@
+'use strict'
+
+/*  ------------------------------------------------------------------------
+
+    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 ROUND      = 0                // rounding mode
+    , TRUNCATE   = 1
+    , ROUND_UP   = 2
+    , ROUND_DOWN = 3
+
+const DECIMAL_PLACES     = 0        // digits counting mode
+    , SIGNIFICANT_DIGITS = 1
+    , TICK_SIZE = 2
+
+const NO_PADDING    = 0             // zero-padding mode
+    , PAD_WITH_ZERO = 1
+
+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) { // avoids scientific notation for too large and too small numbers
+    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 = []
+    , 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 ()
+    }
+    , truncate = (num, precision = 0) => parseFloat (truncate_to_string (num, precision))
+
+function precisionFromString (string) {
+    const split = string.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 (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)
+        , isNegative   = str[0] === '-'
+        , strStart     = isNegative ? 1 : 0
+        , 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
+        , DOT   =  46
+        , ZERO  =  48
+        , ONE   = (ZERO + 1)
+        , FIVE  = (ZERO + 5)
+        , 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
+      , digitsStart = -1                // significant digits
+      , 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
+      , 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
+        , readEnd       = (digitsEnd    < afterDot) ? (afterDot    ) : digitsEnd   // 12(3)000     ----> 123000( )
+
+/*  Compute various sub-ranges       */
+
+    const nSign         =          (signNeeded ? 1 : 0)                // (-)123.456
+        , nBeforeDot    =          (nSign + (afterDot - readStart))    // (-123).456
+        , nAfterDot     = Math.max (readEnd - afterDot, 0)             // -123.(456)
+        , actualLength  =          (readEnd - readStart)               // -(123.456)
+        , desiredLength =          (paddingMode === NO_PADDING)
+                                       ? (actualLength)                // -(123.456)
+                                       : (precisionEnd - readStart)    // -(123.456    )
+
+        , pad           = Math.max (desiredLength - actualLength, 0)   //  -123.456(    )
+        , padStart      =          (nBeforeDot + 1 + nAfterDot)        //  -123.456( )
+        , padEnd        =          (padStart + pad)                    //  -123.456     ( )
+        , 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
+}
+
+/*  ------------------------------------------------------------------------ */
+
+module.exports = {
+    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/base/functions/platform.js

@@ -0,0 +1,38 @@
+"use strict";
+
+// ----------------------------------------------------------------------------
+// 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)
+
+const defaultFetch = typeof (fetch) === "undefined" ? require ('../../static_dependencies/fetch-ponyfill/fetch-node') ().fetch : fetch
+
+// ----------------------------------------------------------------------------
+
+module.exports = {
+
+    isBrowser,
+    isElectron,
+    isWebWorker,
+    isNode,
+    isWindows,
+    defaultFetch,
+}

package/js/base/functions/string.js

@@ -0,0 +1,21 @@
+"use strict";
+
+// ----------------------------------------------------------------------------
+
+const uuid = a => a ? (a ^ Math.random () * 16 >> a / 4).toString (16) : ([1e7]+-1e3+-4e3+-8e3+-1e11).replace (/[018]/g, uuid)
+const uuid16 = a => a ? (a ^ Math.random () * 16 >> a / 4).toString (16) : ([1e5]+1e2+4e2+8e3).replace (/[018]/g, uuid16)
+const uuid22 = a => a ? (a ^ Math.random () * 16 >> a / 4).toString (16) : ([1e7]+1e3+4e3+8e5).replace (/[018]/g, uuid22)
+
+
+// ----------------------------------------------------------------------------
+
+module.exports = {
+
+    uuid
+    , uuid16
+    , uuid22
+    // hasFetchOHLCV → has_fetch_ohlcv; parseHTTPResponse → parse_http_response
+    , unCamelCase: s => s.match (/^[A-Z0-9_]+$/) ? s : (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]).toLowerCase ())
+    , capitalize: s => s.length ? (s.charAt (0).toUpperCase () + s.slice (1)) : s
+    , strip: s => s.replace(/^\s+|\s+$/g, '')
+}

package/js/base/functions/throttle.js

@@ -0,0 +1,79 @@
+"use strict";
+
+/*  ------------------------------------------------------------------------ */
+
+const { now, sleep } = require ('./time')
+
+/*  ------------------------------------------------------------------------ */
+
+class Throttle {
+    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 = 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 sleep (this.config['delay'] * 1000);
+                const current = now ()
+                const elapsed = current - lastTimestamp
+                lastTimestamp = current
+                this.config['tokens'] = Math.min (this.config['tokens'] + (this.config['refillRate'] * elapsed), this.config['capacity'])
+            }
+        }
+    }
+}
+
+function throttle (config) {
+    function inner (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')
+        }
+        cost = (cost === undefined) ? this.config['cost'] : cost
+        this.queue.push ({
+            resolver,
+            cost,
+        })
+        if (!this.running) {
+            this.running = true
+            this.loop ()
+        }
+        return promise
+    }
+    const instance = new Throttle (config)
+    const bound = inner.bind (instance)
+    // useful for inspecting the tokenBucket
+    bound.config = instance.config
+    return bound
+}
+
+module.exports = {
+    throttle,
+}
+
+// ----------------------------------------

package/js/base/functions/time.js

@@ -0,0 +1,210 @@
+'use strict';
+
+/*  ------------------------------------------------------------------------ */
+
+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://stackoverflow.com/questions/60474110
+    if (ms >= 2147483647) {
+        throw new Exception('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
+        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
+}
+
+module.exports = {
+    now
+    , microseconds
+    , milliseconds
+    , seconds
+    , iso8601
+    , parse8601
+    , rfc2616
+    , uuidv1
+    , parseDate
+    , mdy
+    , ymd
+    , yymmdd
+    , yyyymmdd
+    , ymdhms
+    , setTimeout_safe
+    , sleep: (ms) => new Promise ((resolve) => setTimeout_safe (resolve, ms))
+    , TimedOut
+    , 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
+        }
+    }
+}
+
+/*  ------------------------------------------------------------------------ */