ccxt-look 1.81.50

package/js/base/Precise.js

@@ -0,0 +1,283 @@
+'use strict'
+
+const zero = BigInt (0)
+const minusOne = BigInt (-1)
+const base = BigInt (10)
+
+class Precise {
+    constructor (number, decimals = undefined) {
+        if (decimals === undefined) {
+            let modifier = 0
+            number = number.toLowerCase ()
+            if (number.indexOf ('e') > -1) {
+                [ number, modifier ] = number.split ('e')
+                modifier = parseInt (modifier)
+            }
+            const decimalIndex = number.indexOf ('.')
+            this.decimals = (decimalIndex > -1) ? number.length - decimalIndex - 1 : 0
+            const integerString = number.replace ('.', '')
+            this.integer = BigInt (integerString)
+            this.decimals = this.decimals - modifier
+        } else {
+            this.integer = number
+            this.decimals = decimals
+        }
+    }
+
+    mul (other) {
+        // other must be another instance of Precise
+        const integerResult = this.integer * other.integer
+        return new Precise (integerResult, this.decimals + other.decimals)
+    }
+
+    div (other, precision = 18) {
+        const distance = precision - this.decimals + other.decimals
+        let numerator
+        if (distance === 0) {
+            numerator = this.integer
+        } else if (distance < 0) {
+            const exponent = base ** BigInt (-distance)
+            numerator = this.integer / exponent
+        } else {
+            const exponent = base ** BigInt (distance)
+            numerator = this.integer * exponent
+        }
+        const result = numerator / other.integer
+        return new Precise (result, precision)
+    }
+
+    add (other) {
+        if (this.decimals === other.decimals) {
+            const integerResult = this.integer + other.integer
+            return new Precise (integerResult, this.decimals)
+        } else {
+            const [ smaller, bigger ] =
+                (this.decimals > other.decimals) ? [ other, this ] : [ this, other ]
+            const exponent = bigger.decimals - smaller.decimals
+            const normalised = smaller.integer * (base ** BigInt (exponent))
+            const result = normalised + bigger.integer
+            return new Precise (result, bigger.decimals)
+        }
+    }
+
+    mod (other) {
+        const rationizerNumerator = Math.max (-this.decimals + other.decimals, 0)
+        const numerator = this.integer * (base ** BigInt (rationizerNumerator))
+        const rationizerDenominator = Math.max (-other.decimals + this.decimals, 0)
+        const denominator = other.integer * (base ** BigInt (rationizerDenominator))
+        const result = numerator % denominator
+        return new Precise (result, rationizerDenominator + other.decimals)
+    }
+
+    sub (other) {
+        const negative = new Precise (-other.integer, other.decimals)
+        return this.add (negative)
+    }
+
+    abs () {
+        return new Precise (this.integer < 0 ? this.integer * minusOne : this.integer, this.decimals)
+    }
+
+    neg () {
+        return new Precise (-this.integer, this.decimals)
+    }
+
+    min (other) {
+        return this.lt (other) ? this : other
+    }
+
+    max (other) {
+        return this.gt (other) ? this : other
+    }
+
+    gt (other) {
+        const sum = this.sub (other)
+        return sum.integer > 0
+    }
+
+    ge (other) {
+        const sum = this.sub (other)
+        return sum.integer >= 0
+    }
+
+    lt (other) {
+        return other.gt (this)
+    }
+
+    le (other) {
+        return other.ge (this)
+    }
+
+    reduce () {
+        const string = this.integer.toString ()
+        const start = string.length - 1
+        if (start === 0) {
+            if (string === '0') {
+                this.decimals = 0
+            }
+            return this
+        }
+        let i
+        for (i = start; i >= 0; i--) {
+            if (string.charAt (i) !== '0') {
+                break
+            }
+        }
+        const difference = start - i
+        if (difference === 0) {
+            return this
+        }
+        this.decimals -= difference
+        this.integer = BigInt (string.slice (0, i + 1))
+    }
+
+    equals (other) {
+        this.reduce ()
+        other.reduce ()
+        return (this.decimals === other.decimals) && (this.integer === other.integer)
+    }
+
+    toString () {
+        this.reduce ()
+        let sign
+        let abs
+        if (this.integer < 0) {
+            sign = '-'
+            abs = -this.integer
+        } else {
+            sign = ''
+            abs = this.integer
+        }
+        const integerArray = Array.from (abs.toString (this.base).padStart (this.decimals, '0'))
+        const index = integerArray.length - this.decimals
+        let item
+        if (index === 0) {
+            // if we are adding to the front
+            item = '0.'
+        } else if (this.decimals < 0) {
+            item = '0'.repeat (-this.decimals)
+        } else if (this.decimals === 0) {
+            item = ''
+        } else {
+            item = '.'
+        }
+        integerArray.splice (index, 0, item)
+        return sign + integerArray.join ('')
+    }
+
+    static stringMul (string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined
+        }
+        return (new Precise (string1)).mul (new Precise (string2)).toString ()
+    }
+
+    static stringDiv (string1, string2, precision = 18) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined
+        }
+        const string2Precise = new Precise (string2)
+        if (string2Precise.integer === zero) {
+            return undefined
+        }
+        return (new Precise (string1)).div (string2Precise, precision).toString ()
+    }
+
+    static stringAdd (string1, string2) {
+        if ((string1 === undefined) && (string2 === undefined)) {
+            return undefined
+        }
+        if (string1 === undefined) {
+            return string2
+        } else if (string2 === undefined) {
+            return string1
+        }
+        return (new Precise (string1)).add (new Precise (string2)).toString ()
+    }
+
+    static stringSub (string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined
+        }
+        return (new Precise (string1)).sub (new Precise (string2)).toString ()
+    }
+
+    static stringAbs (string) {
+        if (string === undefined) {
+            return undefined
+        }
+        return (new Precise (string)).abs ().toString ()
+    }
+
+    static stringNeg (string) {
+        if (string === undefined) {
+            return undefined
+        }
+        return (new Precise (string)).neg ().toString ()
+    }
+
+    static stringMod (string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined
+        }
+        return (new Precise (string1)).mod (new Precise (string2)).toString ()
+    }
+
+    static stringEquals (string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined
+        }
+        return (new Precise (string1)).equals (new Precise (string2))
+    }
+
+    static stringEq (string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined
+        }
+        return (new Precise (string1)).equals (new Precise (string2))
+    }
+
+    static stringMin (string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined
+        }
+        return (new Precise (string1)).min (new Precise (string2)).toString ()
+    }
+
+    static stringMax (string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined
+        }
+        return (new Precise (string1)).max (new Precise (string2)).toString ()
+    }
+
+    static stringGt (string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined
+        }
+        return (new Precise (string1)).gt (new Precise (string2))
+    }
+
+    static stringGe (string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined
+        }
+        return (new Precise (string1)).ge (new Precise (string2))
+    }
+
+    static stringLt (string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined
+        }
+        return (new Precise (string1)).lt (new Precise (string2))
+    }
+
+    static stringLe (string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined
+        }
+        return (new Precise (string1)).le (new Precise (string2))
+    }
+}
+
+module.exports = Precise;

package/js/base/errorHierarchy.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const errorHierarchy = {
+    'BaseError': {
+        'ExchangeError': {
+            'AuthenticationError': {
+                'PermissionDenied': {
+                    'AccountNotEnabled': {},
+                },
+                'AccountSuspended': {},
+            },
+            'ArgumentsRequired': {},
+            'BadRequest': {
+                'BadSymbol': {},
+                'MarginModeAlreadySet': {},
+            },
+            'BadResponse': {
+                'NullResponse': {},
+            },
+            'InsufficientFunds': {},
+            'InvalidAddress': {
+                'AddressPending': {},
+            },
+            'InvalidOrder': {
+                'OrderNotFound': {},
+                'OrderNotCached': {},
+                'CancelPending': {},
+                'OrderImmediatelyFillable': {},
+                'OrderNotFillable': {},
+                'DuplicateOrderId': {},
+            },
+            'NotSupported': {},
+        },
+        'NetworkError': {
+            'DDoSProtection': {
+                'RateLimitExceeded': {},
+            },
+            'ExchangeNotAvailable': {
+                'OnMaintenance': {},
+            },
+            'InvalidNonce': {},
+            'RequestTimeout': {},
+        },
+    },
+};
+
+module.exports = errorHierarchy;

package/js/base/errors.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const errorHierarchy = require ('./errorHierarchy.js')
+
+/*  ------------------------------------------------------------------------ */
+
+function subclass (BaseClass, classes, namespace = {}) {
+
+    for (const [className, subclasses] of Object.entries (classes)) {
+
+        const Class = Object.assign (namespace, {
+
+        /*  By creating a named property, we trick compiler to assign our class constructor function a name.
+            Otherwise, all our error constructors would be shown as [Function: Error] in the debugger! And
+            the super-useful `e.constructor.name` magic wouldn't work — we then would have no chance to
+            obtain a error type string from an error instance programmatically!                               */
+
+            [className]: class extends BaseClass {
+
+                constructor (message) {
+
+                    super (message)
+
+                /*  A workaround to make `instanceof` work on custom Error classes in transpiled ES5.
+                    See my blog post for the explanation of this hack:
+
+                    https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801        */
+
+                    this.constructor = Class
+                    this.__proto__   = Class.prototype
+                    this.name        = className
+                    this.message     = message
+
+                    // https://github.com/Microsoft/TypeScript/wiki/FAQ#why-doesnt-extending-built-ins-like-error-array-and-map-work
+
+                    Object.setPrototypeOf (this, Class.prototype)
+                }
+            }
+
+        })[className]
+
+        subclass (Class, subclasses, namespace)
+    }
+
+    return namespace
+}
+
+/*  ------------------------------------------------------------------------ */
+
+module.exports = subclass (
+    // Root class
+    Error,
+    // Derived class hierarchy
+    errorHierarchy
+)

package/js/base/functions/crypto.js

@@ -0,0 +1,158 @@
+'use strict'
+
+/*  ------------------------------------------------------------------------ */
+
+const CryptoJS = require ('../../static_dependencies/crypto-js/crypto-js')
+const { capitalize } = require ('./string')
+const { stringToBase64, urlencodeBase64 } = require ('./encode')
+const NodeRSA = require ('./../../static_dependencies/node-rsa/NodeRSA')
+const { binaryToBase58, byteArrayToWordArray } = require ('./encode')
+const elliptic = require ('./../../static_dependencies/elliptic/lib/elliptic')
+const EC = elliptic.ec
+const EDDSA = elliptic.eddsa
+const { ArgumentsRequired } = require ('./../errors')
+const BN = require ('../../static_dependencies/BN/bn.js')
+
+/*  ------------------------------------------------------------------------ */
+
+const hash = (request, hash = 'md5', digest = 'hex') => {
+    const options = {}
+    if (hash === 'keccak') {
+        hash = 'SHA3'
+        options['outputLength'] = 256
+    }
+    const result = CryptoJS[hash.toUpperCase ()] (request, options)
+    return (digest === 'binary') ? result : result.toString (CryptoJS.enc[capitalize (digest)])
+}
+
+/*  .............................................   */
+
+const hmac = (request, secret, hash = 'sha256', digest = 'hex') => {
+    const result = CryptoJS['Hmac' + hash.toUpperCase ()] (request, secret)
+    if (digest) {
+        const encoding = (digest === 'binary') ? 'Latin1' : capitalize (digest)
+        return result.toString (CryptoJS.enc[capitalize (encoding)])
+    }
+    return result
+}
+
+/*  .............................................   */
+
+function rsa (request, secret, alg = 'RS256') {
+    const algos = {
+        'RS256': 'pkcs1-sha256',
+        'RS512': 'pkcs1-sha512',
+    }
+    if (!(alg in algos)) {
+        throw new ExchangeError (alg + ' is not a supported rsa signing algorithm.')
+    }
+    const algorithm = algos[alg]
+    let key = new NodeRSA (secret, {
+        'environment': 'browser',
+        'signingScheme': algorithm,
+    })
+    return key.sign (request, 'base64', 'binary')
+}
+
+
+/**
+ * @return {string}
+ */
+function jwt (request, secret, alg = 'HS256') {
+    const algos = {
+        'HS256': 'sha256',
+        'HS384': 'sha384',
+        'HS512': 'sha512',
+    };
+    const encodedHeader = urlencodeBase64 (stringToBase64 (JSON.stringify ({ 'alg': alg, 'typ': 'JWT' })))
+    const encodedData = urlencodeBase64 (stringToBase64 (JSON.stringify (request)))
+    const token = [ encodedHeader, encodedData ].join ('.')
+    const algoType = alg.slice (0, 2);
+    const algorithm = algos[alg]
+    let signature = undefined
+    if (algoType === 'HS') {
+        signature = urlencodeBase64 (hmac (token, secret, algorithm, 'base64'))
+    } else if (algoType === 'RS') {
+        signature = urlencodeBase64 (rsa (token, secret, alg))
+    }
+    return [ token, signature ].join ('.')
+}
+
+function ecdsa (request, secret, algorithm = 'p256', hashFunction = undefined, fixedLength = false) {
+    let digest = request
+    if (hashFunction !== undefined) {
+        digest = hash (request, hashFunction, 'hex')
+    }
+    const curve = new EC (algorithm)
+    let signature = curve.sign (digest, secret, 'hex',  { 'canonical': true })
+    let counter = new BN ('0')
+    const minimum_size = new BN ('1').shln (8 * 31).sub (new BN ('1'))
+    while (fixedLength && (signature.r.gt (curve.nh) || signature.r.lte (minimum_size) || signature.s.lte (minimum_size))) {
+        signature = curve.sign (digest, secret, 'hex',  { 'canonical': true, 'extraEntropy': counter.toArray ('le', 32)})
+        counter = counter.add (new BN ('1'))
+    }
+    return {
+        'r': signature.r.toString (16).padStart (64, '0'),
+        's': signature.s.toString (16).padStart (64, '0'),
+        'v': signature.recoveryParam,
+    }
+}
+
+
+function eddsa (request, secret, algorithm = 'ed25519') {
+    // used for waves.exchange (that's why the output is base58)
+    const curve = new EDDSA (algorithm)
+    const signature = curve.signModified (request, secret)
+    return binaryToBase58 (byteArrayToWordArray (signature.toBytes ()))
+}
+
+/*  ------------------------------------------------------------------------ */
+
+const totp = (secret) => {
+
+    const dec2hex = s => ((s < 15.5 ? '0' : '') + Math.round (s).toString (16))
+        , hex2dec = s => parseInt (s, 16)
+        , leftpad = (s, p) => (p + s).slice (-p.length) // both s and p are short strings
+
+    const base32tohex = (base32) => {
+        let base32chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'
+        let bits = ''
+        let hex = ''
+        for (let i = 0; i < base32.length; i++) {
+            let val = base32chars.indexOf (base32.charAt (i).toUpperCase ())
+            bits += leftpad (val.toString (2), '00000')
+        }
+        for (let i = 0; i + 4 <= bits.length; i += 4) {
+            let chunk = bits.substr (i, 4)
+            hex = hex + parseInt (chunk, 2).toString (16)
+        }
+        return hex
+    }
+
+    const getOTP = (secret) => {
+        secret = secret.replace (' ', '') // support 2fa-secrets with spaces like "4TDV WOGO" → "4TDVWOGO"
+        let epoch = Math.round (new Date ().getTime () / 1000.0)
+        let time = leftpad (dec2hex (Math.floor (epoch / 30)), '0000000000000000')
+        let hmacRes = hmac (CryptoJS.enc.Hex.parse (time), CryptoJS.enc.Hex.parse (base32tohex (secret)), 'sha1', 'hex')
+        let offset = hex2dec (hmacRes.substring (hmacRes.length - 1))
+        let otp = (hex2dec (hmacRes.substr (offset * 2, 8)) & hex2dec ('7fffffff')) + ''
+        otp = (otp).substr (otp.length - 6, 6)
+        return otp
+    }
+
+    return getOTP (secret)
+}
+
+/*  ------------------------------------------------------------------------ */
+
+module.exports = {
+    hash,
+    hmac,
+    jwt,
+    totp,
+    rsa,
+    ecdsa,
+    eddsa,
+}
+
+/*  ------------------------------------------------------------------------ */

package/js/base/functions/encode.js

@@ -0,0 +1,118 @@
+"use strict";
+
+/*  ------------------------------------------------------------------------ */
+
+const CryptoJS = require ('../../static_dependencies/crypto-js/crypto-js')
+const qs       = require ('../../static_dependencies/qs/index')
+const BN = require ('../../static_dependencies/BN/bn')
+
+
+/*  ------------------------------------------------------------------------ */
+
+// global vars for base58 encoding
+const base58Alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+let base58Decoder = null
+let base58Encoder = null
+
+/*  ------------------------------------------------------------------------ */
+
+module.exports =
+
+    { json:   (data, params = undefined) => JSON.stringify (data)
+
+    , isJsonEncodedObject: object => (
+        (typeof object === 'string') &&
+        (object.length >= 2) &&
+        ((object[0] === '{') || (object[0] === '['))
+    )
+
+    , stringToBinary: string => CryptoJS.enc.Latin1.parse (string)
+    , stringToBase64: string => CryptoJS.enc.Latin1.parse (string).toString (CryptoJS.enc.Base64)
+    , base64ToBinary: string => CryptoJS.enc.Base64.parse (string)
+    , base64ToString: string => CryptoJS.enc.Base64.parse (string).toString (CryptoJS.enc.Utf8)
+    , binaryToBase64: binary => binary.toString (CryptoJS.enc.Base64)
+    , base16ToBinary: string => CryptoJS.enc.Hex.parse (string)
+    , binaryToBase16: binary => binary.toString (CryptoJS.enc.Hex)
+    , binaryConcat: (...args) => args.reduce ((a, b) => a.concat (b))
+    , binaryConcatArray: (arr) => arr.reduce ((a, b) => a.concat (b))
+
+    , urlencode: object => qs.stringify (object)
+    , urlencodeNested: object => qs.stringify (object) // implemented only in python
+    , urlencodeWithArrayRepeat: object => qs.stringify (object, { arrayFormat: 'repeat' })
+    , rawencode: object => qs.stringify (object, { encode: false })
+    , encode: x => x
+    , decode: x => x
+
+    // Url-safe-base64 without equals signs, with + replaced by - and slashes replaced by underscores
+
+    , urlencodeBase64: base64string => base64string.replace (/[=]+$/, '')
+                                                   .replace (/\+/g, '-')
+                                                   .replace (/\//g, '_')
+
+    , numberToLE: (n, padding) => {
+        const hexArray = new BN (n).toArray ('le', padding)
+        return byteArrayToWordArray (hexArray)
+    }
+
+    , numberToBE: (n, padding) => {
+        const hexArray = new BN (n).toArray ('be', padding)
+        return byteArrayToWordArray (hexArray)
+    }
+
+    , base58ToBinary: (string) => {
+        if (!base58Decoder) {
+            base58Decoder = {}
+            base58Encoder = {}
+            for (let i = 0; i < 58; i++) {
+                const c = base58Alphabet[i]
+                const bigNum = new BN (i)
+                base58Decoder[c] = bigNum
+                base58Encoder[bigNum] = c
+            }
+        }
+        let result = new BN (0)
+        const base = new BN (58)
+        for (let i = 0; i < string.length; i++) {
+            const character = string[i]
+            result.imul (base)
+            result.iadd (base58Decoder[character])
+        }
+        return byteArrayToWordArray (result.toArray ('be'))
+    }
+
+    , binaryToBase58: (wordArray) => {
+        if (!base58Encoder) {
+            base58Decoder = {}
+            base58Encoder = {}
+            for (let i = 0; i < 58; i++) {
+                const c = base58Alphabet[i]
+                const bigNum = new BN (i)
+                base58Decoder[c] = bigNum
+                base58Encoder[bigNum] = c
+            }
+        }
+        const base = new BN (58)
+        // hex is only compatible encoding between cryptojs and BN
+        const hexString = wordArray.toString (CryptoJS.enc.Hex)
+        let result = new BN (hexString, 16)
+        let string = []
+        while (!result.isZero ()) {
+            const { div, mod } = result.divmod (base)
+            result = div
+            string.push (base58Encoder[mod])
+        }
+        return string.reverse ().join ('')
+    }
+}
+
+function byteArrayToWordArray (ba) {
+    const wa = []
+    for (let i = 0; i < ba.length; i++) {
+        wa[(i / 4) | 0] |= ba[i] << (24 - 8 * i)
+    }
+    return CryptoJS.lib.WordArray.create (wa, ba.length)
+}
+
+module.exports['byteArrayToWordArray'] = byteArrayToWordArray
+
+/*  ------------------------------------------------------------------------ */