ccxt 4.2.60 → 4.2.62

package/dist/cjs/src/static_dependencies/ethers/utils/properties.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ *  Property helper functions.
+ *
+ *  @_subsection api/utils:Properties  [about-properties]
+ */
+function checkType(value, type, name) {
+    const types = type.split("|").map(t => t.trim());
+    for (let i = 0; i < types.length; i++) {
+        switch (type) {
+            case "any":
+                return;
+            case "bigint":
+            case "boolean":
+            case "number":
+            case "string":
+                if (typeof (value) === type) {
+                    return;
+                }
+        }
+    }
+    const error = new Error(`invalid value for type ${type}`);
+    error.code = "INVALID_ARGUMENT";
+    error.argument = `value.${name}`;
+    error.value = value;
+    throw error;
+}
+/**
+ *  Assigns the %%values%% to %%target%% as read-only values.
+ *
+ *  It %%types%% is specified, the values are checked.
+ */
+function defineProperties(target, values, types) {
+    for (let key in values) {
+        let value = values[key];
+        const type = (types ? types[key] : null);
+        if (type) {
+            checkType(value, type, key);
+        }
+        Object.defineProperty(target, key, { enumerable: true, value, writable: false });
+    }
+}
+
+exports.defineProperties = defineProperties;

package/dist/cjs/src/static_dependencies/ethers/utils/utf8.js

@@ -0,0 +1,218 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var data = require('./data.js');
+var errors = require('./errors.js');
+
+/**
+ *  Using strings in Ethereum (or any security-basd system) requires
+ *  additional care. These utilities attempt to mitigate some of the
+ *  safety issues as well as provide the ability to recover and analyse
+ *  strings.
+ *
+ *  @_subsection api/utils:Strings and UTF-8  [about-strings]
+ */
+function errorFunc(reason, offset, bytes, output, badCodepoint) {
+    errors.assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes);
+}
+function ignoreFunc(reason, offset, bytes, output, badCodepoint) {
+    // If there is an invalid prefix (including stray continuation), skip any additional continuation bytes
+    if (reason === "BAD_PREFIX" || reason === "UNEXPECTED_CONTINUE") {
+        let i = 0;
+        for (let o = offset + 1; o < bytes.length; o++) {
+            if (bytes[o] >> 6 !== 0x02) {
+                break;
+            }
+            i++;
+        }
+        return i;
+    }
+    // This byte runs us past the end of the string, so just jump to the end
+    // (but the first byte was read already read and therefore skipped)
+    if (reason === "OVERRUN") {
+        return bytes.length - offset - 1;
+    }
+    // Nothing to skip
+    return 0;
+}
+function replaceFunc(reason, offset, bytes, output, badCodepoint) {
+    // Overlong representations are otherwise "valid" code points; just non-deistingtished
+    if (reason === "OVERLONG") {
+        errors.assertArgument(typeof (badCodepoint) === "number", "invalid bad code point for replacement", "badCodepoint", badCodepoint);
+        output.push(badCodepoint);
+        return 0;
+    }
+    // Put the replacement character into the output
+    output.push(0xfffd);
+    // Otherwise, process as if ignoring errors
+    return ignoreFunc(reason, offset, bytes);
+}
+/**
+ *  A handful of popular, built-in UTF-8 error handling strategies.
+ *
+ *  **``"error"``** - throws on ANY illegal UTF-8 sequence or
+ *  non-canonical (overlong) codepoints (this is the default)
+ *
+ *  **``"ignore"``** - silently drops any illegal UTF-8 sequence
+ *  and accepts non-canonical (overlong) codepoints
+ *
+ *  **``"replace"``** - replace any illegal UTF-8 sequence with the
+ *  UTF-8 replacement character (i.e. ``"\\ufffd"``) and accepts
+ *  non-canonical (overlong) codepoints
+ *
+ *  @returns: Record<"error" | "ignore" | "replace", Utf8ErrorFunc>
+ */
+const Utf8ErrorFuncs = Object.freeze({
+    error: errorFunc,
+    ignore: ignoreFunc,
+    replace: replaceFunc
+});
+// http://stackoverflow.com/questions/13356493/decode-utf-8-with-javascript#13691499
+function getUtf8CodePoints(_bytes, onError) {
+    if (onError == null) {
+        onError = Utf8ErrorFuncs.error;
+    }
+    const bytes = data.getBytes(_bytes, "bytes");
+    const result = [];
+    let i = 0;
+    // Invalid bytes are ignored
+    while (i < bytes.length) {
+        const c = bytes[i++];
+        // 0xxx xxxx
+        if (c >> 7 === 0) {
+            result.push(c);
+            continue;
+        }
+        // Multibyte; how many bytes left for this character?
+        let extraLength = null;
+        let overlongMask = null;
+        // 110x xxxx 10xx xxxx
+        if ((c & 0xe0) === 0xc0) {
+            extraLength = 1;
+            overlongMask = 0x7f;
+            // 1110 xxxx 10xx xxxx 10xx xxxx
+        }
+        else if ((c & 0xf0) === 0xe0) {
+            extraLength = 2;
+            overlongMask = 0x7ff;
+            // 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx
+        }
+        else if ((c & 0xf8) === 0xf0) {
+            extraLength = 3;
+            overlongMask = 0xffff;
+        }
+        else {
+            if ((c & 0xc0) === 0x80) {
+                i += onError("UNEXPECTED_CONTINUE", i - 1, bytes, result);
+            }
+            else {
+                i += onError("BAD_PREFIX", i - 1, bytes, result);
+            }
+            continue;
+        }
+        // Do we have enough bytes in our data?
+        if (i - 1 + extraLength >= bytes.length) {
+            i += onError("OVERRUN", i - 1, bytes, result);
+            continue;
+        }
+        // Remove the length prefix from the char
+        let res = c & ((1 << (8 - extraLength - 1)) - 1);
+        for (let j = 0; j < extraLength; j++) {
+            let nextChar = bytes[i];
+            // Invalid continuation byte
+            if ((nextChar & 0xc0) != 0x80) {
+                i += onError("MISSING_CONTINUE", i, bytes, result);
+                res = null;
+                break;
+            }
+            res = (res << 6) | (nextChar & 0x3f);
+            i++;
+        }
+        // See above loop for invalid continuation byte
+        if (res === null) {
+            continue;
+        }
+        // Maximum code point
+        if (res > 0x10ffff) {
+            i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes, result, res);
+            continue;
+        }
+        // Reserved for UTF-16 surrogate halves
+        if (res >= 0xd800 && res <= 0xdfff) {
+            i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes, result, res);
+            continue;
+        }
+        // Check for overlong sequences (more bytes than needed)
+        if (res <= overlongMask) {
+            i += onError("OVERLONG", i - 1 - extraLength, bytes, result, res);
+            continue;
+        }
+        result.push(res);
+    }
+    return result;
+}
+// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array
+/**
+ *  Returns the UTF-8 byte representation of %%str%%.
+ *
+ *  If %%form%% is specified, the string is normalized.
+ */
+function toUtf8Bytes(str, form) {
+    if (form != null) {
+        errors.assertNormalize(form);
+        str = str.normalize(form);
+    }
+    let result = [];
+    for (let i = 0; i < str.length; i++) {
+        const c = str.charCodeAt(i);
+        if (c < 0x80) {
+            result.push(c);
+        }
+        else if (c < 0x800) {
+            result.push((c >> 6) | 0xc0);
+            result.push((c & 0x3f) | 0x80);
+        }
+        else if ((c & 0xfc00) == 0xd800) {
+            i++;
+            const c2 = str.charCodeAt(i);
+            errors.assertArgument(i < str.length && ((c2 & 0xfc00) === 0xdc00), "invalid surrogate pair", "str", str);
+            // Surrogate Pair
+            const pair = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);
+            result.push((pair >> 18) | 0xf0);
+            result.push(((pair >> 12) & 0x3f) | 0x80);
+            result.push(((pair >> 6) & 0x3f) | 0x80);
+            result.push((pair & 0x3f) | 0x80);
+        }
+        else {
+            result.push((c >> 12) | 0xe0);
+            result.push(((c >> 6) & 0x3f) | 0x80);
+            result.push((c & 0x3f) | 0x80);
+        }
+    }
+    return new Uint8Array(result);
+}
+//export 
+function _toUtf8String(codePoints) {
+    return codePoints.map((codePoint) => {
+        if (codePoint <= 0xffff) {
+            return String.fromCharCode(codePoint);
+        }
+        codePoint -= 0x10000;
+        return String.fromCharCode((((codePoint >> 10) & 0x3ff) + 0xd800), ((codePoint & 0x3ff) + 0xdc00));
+    }).join("");
+}
+/**
+ *  Returns the string represented by the UTF-8 data %%bytes%%.
+ *
+ *  When %%onError%% function is specified, it is called on UTF-8
+ *  errors allowing recovery using the [[Utf8ErrorFunc]] API.
+ *  (default: [error](Utf8ErrorFuncs))
+ */
+function toUtf8String(bytes, onError) {
+    return _toUtf8String(getUtf8CodePoints(bytes, onError));
+}
+
+exports.Utf8ErrorFuncs = Utf8ErrorFuncs;
+exports.toUtf8Bytes = toUtf8Bytes;
+exports.toUtf8String = toUtf8String;

package/dist/cjs/src/static_dependencies/messagepack/msgpack.js

@@ -0,0 +1,292 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// (function () {
+// 	"use strict";
+// Serializes a value to a MessagePack byte array.
+//
+// data: The value to serialize. This can be a scalar, array or object.
+// options: An object that defines additional options.
+// - multiple: (boolean) Indicates whether multiple values in data are concatenated to multiple MessagePack arrays. Default: false.
+// - invalidTypeReplacement:
+//   (any) The value that is used to replace values of unsupported types.
+//   (function) A function that returns such a value, given the original value as parameter.
+function serialize(data, options) {
+    if (options && options.multiple && !Array.isArray(data)) {
+        throw new Error("Invalid argument type: Expected an Array to serialize multiple values.");
+    }
+    const pow32 = 0x100000000; // 2^32
+    let floatBuffer, floatView;
+    let array = new Uint8Array(128);
+    let length = 0;
+    if (options && options.multiple) {
+        for (let i = 0; i < data.length; i++) {
+            append(data[i]);
+        }
+    }
+    else {
+        append(data);
+    }
+    return array.subarray(0, length);
+    function append(data, isReplacement) {
+        switch (typeof data) {
+            case "undefined":
+                appendNull();
+                break;
+            case "boolean":
+                appendBoolean(data);
+                break;
+            case "number":
+                appendNumber(data);
+                break;
+            case "string":
+                appendString(data);
+                break;
+            case "object":
+                if (data === null)
+                    appendNull();
+                else if (data instanceof Date)
+                    appendDate(data);
+                else if (Array.isArray(data))
+                    appendArray(data);
+                else if (data instanceof Uint8Array || data instanceof Uint8ClampedArray)
+                    appendBinArray(data);
+                else if (data instanceof Int8Array || data instanceof Int16Array || data instanceof Uint16Array ||
+                    data instanceof Int32Array || data instanceof Uint32Array ||
+                    data instanceof Float32Array || data instanceof Float64Array)
+                    appendArray(data);
+                else
+                    appendObject(data);
+                break;
+            default:
+                if (!isReplacement && options && options.invalidTypeReplacement) {
+                    if (typeof options.invalidTypeReplacement === "function")
+                        append(options.invalidTypeReplacement(data), true);
+                    else
+                        append(options.invalidTypeReplacement, true);
+                }
+                else {
+                    throw new Error("Invalid argument type: The type '" + (typeof data) + "' cannot be serialized.");
+                }
+        }
+    }
+    function appendNull(data) {
+        appendByte(0xc0);
+    }
+    function appendBoolean(data) {
+        appendByte(data ? 0xc3 : 0xc2);
+    }
+    function appendNumber(data) {
+        if (isFinite(data) && Math.floor(data) === data) {
+            // Integer
+            if (data >= 0 && data <= 0x7f) {
+                appendByte(data);
+            }
+            else if (data < 0 && data >= -0x20) {
+                appendByte(data);
+            }
+            else if (data > 0 && data <= 0xff) { // uint8
+                appendBytes([0xcc, data]);
+            }
+            else if (data >= -0x80 && data <= 0x7f) { // int8
+                appendBytes([0xd0, data]);
+            }
+            else if (data > 0 && data <= 0xffff) { // uint16
+                appendBytes([0xcd, data >>> 8, data]);
+            }
+            else if (data >= -0x8000 && data <= 0x7fff) { // int16
+                appendBytes([0xd1, data >>> 8, data]);
+            }
+            else if (data > 0 && data <= 0xffffffff) { // uint32
+                appendBytes([0xce, data >>> 24, data >>> 16, data >>> 8, data]);
+            }
+            else if (data >= -0x80000000 && data <= 0x7fffffff) { // int32
+                appendBytes([0xd2, data >>> 24, data >>> 16, data >>> 8, data]);
+            }
+            else if (data > 0 && data <= 0xffffffffffffffff) { // uint64
+                // Split 64 bit number into two 32 bit numbers because JavaScript only regards
+                // 32 bits for bitwise operations.
+                let hi = data / pow32;
+                let lo = data % pow32;
+                appendBytes([0xcf, hi >>> 24, hi >>> 16, hi >>> 8, hi, lo >>> 24, lo >>> 16, lo >>> 8, lo]);
+            }
+            else if (data >= -0x8000000000000000 && data <= 0x7fffffffffffffff) { // int64
+                appendByte(0xd3);
+                appendInt64(data);
+            }
+            else if (data < 0) { // below int64
+                appendBytes([0xd3, 0x80, 0, 0, 0, 0, 0, 0, 0]);
+            }
+            else { // above uint64
+                appendBytes([0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
+            }
+        }
+        else {
+            // Float
+            if (!floatView) {
+                floatBuffer = new ArrayBuffer(8);
+                floatView = new DataView(floatBuffer);
+            }
+            floatView.setFloat64(0, data);
+            appendByte(0xcb);
+            appendBytes(new Uint8Array(floatBuffer));
+        }
+    }
+    function appendString(data) {
+        let bytes = encodeUtf8(data);
+        let length = bytes.length;
+        if (length <= 0x1f)
+            appendByte(0xa0 + length);
+        else if (length <= 0xff)
+            appendBytes([0xd9, length]);
+        else if (length <= 0xffff)
+            appendBytes([0xda, length >>> 8, length]);
+        else
+            appendBytes([0xdb, length >>> 24, length >>> 16, length >>> 8, length]);
+        appendBytes(bytes);
+    }
+    function appendArray(data) {
+        let length = data.length;
+        if (length <= 0xf)
+            appendByte(0x90 + length);
+        else if (length <= 0xffff)
+            appendBytes([0xdc, length >>> 8, length]);
+        else
+            appendBytes([0xdd, length >>> 24, length >>> 16, length >>> 8, length]);
+        for (let index = 0; index < length; index++) {
+            append(data[index]);
+        }
+    }
+    function appendBinArray(data) {
+        let length = data.length;
+        if (length <= 0xf)
+            appendBytes([0xc4, length]);
+        else if (length <= 0xffff)
+            appendBytes([0xc5, length >>> 8, length]);
+        else
+            appendBytes([0xc6, length >>> 24, length >>> 16, length >>> 8, length]);
+        appendBytes(data);
+    }
+    function appendObject(data) {
+        let length = 0;
+        for (let key in data) {
+            if (data[key] !== undefined) {
+                length++;
+            }
+        }
+        if (length <= 0xf)
+            appendByte(0x80 + length);
+        else if (length <= 0xffff)
+            appendBytes([0xde, length >>> 8, length]);
+        else
+            appendBytes([0xdf, length >>> 24, length >>> 16, length >>> 8, length]);
+        for (let key in data) {
+            let value = data[key];
+            if (value !== undefined) {
+                append(key);
+                append(value);
+            }
+        }
+    }
+    function appendDate(data) {
+        let sec = data.getTime() / 1000;
+        if (data.getMilliseconds() === 0 && sec >= 0 && sec < 0x100000000) { // 32 bit seconds
+            appendBytes([0xd6, 0xff, sec >>> 24, sec >>> 16, sec >>> 8, sec]);
+        }
+        else if (sec >= 0 && sec < 0x400000000) { // 30 bit nanoseconds, 34 bit seconds
+            let ns = data.getMilliseconds() * 1000000;
+            appendBytes([0xd7, 0xff, ns >>> 22, ns >>> 14, ns >>> 6, ((ns << 2) >>> 0) | (sec / pow32), sec >>> 24, sec >>> 16, sec >>> 8, sec]);
+        }
+        else { // 32 bit nanoseconds, 64 bit seconds, negative values allowed
+            let ns = data.getMilliseconds() * 1000000;
+            appendBytes([0xc7, 12, 0xff, ns >>> 24, ns >>> 16, ns >>> 8, ns]);
+            appendInt64(sec);
+        }
+    }
+    function appendByte(byte) {
+        if (array.length < length + 1) {
+            let newLength = array.length * 2;
+            while (newLength < length + 1)
+                newLength *= 2;
+            let newArray = new Uint8Array(newLength);
+            newArray.set(array);
+            array = newArray;
+        }
+        array[length] = byte;
+        length++;
+    }
+    function appendBytes(bytes) {
+        if (array.length < length + bytes.length) {
+            let newLength = array.length * 2;
+            while (newLength < length + bytes.length)
+                newLength *= 2;
+            let newArray = new Uint8Array(newLength);
+            newArray.set(array);
+            array = newArray;
+        }
+        array.set(bytes, length);
+        length += bytes.length;
+    }
+    function appendInt64(value) {
+        // Split 64 bit number into two 32 bit numbers because JavaScript only regards 32 bits for
+        // bitwise operations.
+        let hi, lo;
+        if (value >= 0) {
+            // Same as uint64
+            hi = value / pow32;
+            lo = value % pow32;
+        }
+        else {
+            // Split absolute value to high and low, then NOT and ADD(1) to restore negativity
+            value++;
+            hi = Math.abs(value) / pow32;
+            lo = Math.abs(value) % pow32;
+            hi = ~hi;
+            lo = ~lo;
+        }
+        appendBytes([hi >>> 24, hi >>> 16, hi >>> 8, hi, lo >>> 24, lo >>> 16, lo >>> 8, lo]);
+    }
+}
+// Encodes a string to UTF-8 bytes.
+function encodeUtf8(str) {
+    // Prevent excessive array allocation and slicing for all 7-bit characters
+    let ascii = true, length = str.length;
+    for (let x = 0; x < length; x++) {
+        if (str.charCodeAt(x) > 127) {
+            ascii = false;
+            break;
+        }
+    }
+    // Based on: https://gist.github.com/pascaldekloe/62546103a1576803dade9269ccf76330
+    let i = 0, bytes = new Uint8Array(str.length * (ascii ? 1 : 4));
+    for (let ci = 0; ci !== length; ci++) {
+        let c = str.charCodeAt(ci);
+        if (c < 128) {
+            bytes[i++] = c;
+            continue;
+        }
+        if (c < 2048) {
+            bytes[i++] = c >> 6 | 192;
+        }
+        else {
+            if (c > 0xd7ff && c < 0xdc00) {
+                if (++ci >= length)
+                    throw new Error("UTF-8 encode: incomplete surrogate pair");
+                let c2 = str.charCodeAt(ci);
+                if (c2 < 0xdc00 || c2 > 0xdfff)
+                    throw new Error("UTF-8 encode: second surrogate character 0x" + c2.toString(16) + " at index " + ci + " out of range");
+                c = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);
+                bytes[i++] = c >> 18 | 240;
+                bytes[i++] = c >> 12 & 63 | 128;
+            }
+            else
+                bytes[i++] = c >> 12 | 224;
+            bytes[i++] = c >> 6 & 63 | 128;
+        }
+        bytes[i++] = c & 63 | 128;
+    }
+    return ascii ? bytes : bytes.subarray(0, i);
+}
+
+exports.serialize = serialize;

package/dist/cjs/src/tokocrypto.js

@@ -1016,8 +1016,28 @@ class tokocrypto extends tokocrypto$1 {
                 request['limit'] = limit;
             }
             const responseInner = this.publicGetOpenV1MarketTrades(this.extend(request, params));
-            const data = this.safeValue(responseInner, 'data', {});
-            return this.parseTrades(data, market, since, limit);
+            //
+            //    {
+            //       "code": 0,
+            //       "msg": "success",
+            //       "data": {
+            //           "list": [
+            //                {
+            //                    "id": 28457,
+            //                    "price": "4.00000100",
+            //                    "qty": "12.00000000",
+            //                    "time": 1499865549590,
+            //                    "isBuyerMaker": true,
+            //                    "isBestMatch": true
+            //                }
+            //            ]
+            //        },
+            //        "timestamp": 1571921637091
+            //    }
+            //
+            const data = this.safeDict(responseInner, 'data', {});
+            const list = this.safeList(data, 'list', []);
+            return this.parseTrades(list, market, since, limit);
         }
         if (limit !== undefined) {
             request['limit'] = limit; // default = 500, maximum = 1000