ccxt 4.2.60 → 4.2.62

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

@@ -0,0 +1,134 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var errors = require('./errors.js');
+
+/**
+ *  Some data helpers.
+ *
+ *
+ *  @_subsection api/utils:Data Helpers  [about-data]
+ */
+function _getBytes(value, name, copy) {
+    if (value instanceof Uint8Array) {
+        if (copy) {
+            return new Uint8Array(value);
+        }
+        return value;
+    }
+    if (typeof (value) === "string" && value.match(/^0x([0-9a-f][0-9a-f])*$/i)) {
+        const result = new Uint8Array((value.length - 2) / 2);
+        let offset = 2;
+        for (let i = 0; i < result.length; i++) {
+            result[i] = parseInt(value.substring(offset, offset + 2), 16);
+            offset += 2;
+        }
+        return result;
+    }
+    errors.assertArgument(false, "invalid BytesLike value", name || "value", value);
+}
+/**
+ *  Get a typed Uint8Array for %%value%%. If already a Uint8Array
+ *  the original %%value%% is returned; if a copy is required use
+ *  [[getBytesCopy]].
+ *
+ *  @see: getBytesCopy
+ */
+function getBytes(value, name) {
+    return _getBytes(value, name, false);
+}
+/**
+ *  Get a typed Uint8Array for %%value%%, creating a copy if necessary
+ *  to prevent any modifications of the returned value from being
+ *  reflected elsewhere.
+ *
+ *  @see: getBytes
+ */
+function getBytesCopy(value, name) {
+    return _getBytes(value, name, true);
+}
+/**
+ *  Returns true if %%value%% is a valid [[HexString]].
+ *
+ *  If %%length%% is ``true`` or a //number//, it also checks that
+ *  %%value%% is a valid [[DataHexString]] of %%length%% (if a //number//)
+ *  bytes of data (e.g. ``0x1234`` is 2 bytes).
+ */
+function isHexString(value, length) {
+    if (typeof (value) !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
+        return false;
+    }
+    if (typeof (length) === "number" && value.length !== 2 + 2 * length) {
+        return false;
+    }
+    if (length === true && (value.length % 2) !== 0) {
+        return false;
+    }
+    return true;
+}
+/**
+ *  Returns true if %%value%% is a valid representation of arbitrary
+ *  data (i.e. a valid [[DataHexString]] or a Uint8Array).
+ */
+function isBytesLike(value) {
+    return (isHexString(value, true) || (value instanceof Uint8Array));
+}
+const HexCharacters = "0123456789abcdef";
+/**
+ *  Returns a [[DataHexString]] representation of %%data%%.
+ */
+function hexlify(data) {
+    const bytes = getBytes(data);
+    let result = "0x";
+    for (let i = 0; i < bytes.length; i++) {
+        const v = bytes[i];
+        result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];
+    }
+    return result;
+}
+/**
+ *  Returns a [[DataHexString]] by concatenating all values
+ *  within %%data%%.
+ */
+function concat(datas) {
+    return "0x" + datas.map((d) => hexlify(d).substring(2)).join("");
+}
+function zeroPad(data, length, left) {
+    const bytes = getBytes(data);
+    errors.assert(length >= bytes.length, "padding exceeds data length", "BUFFER_OVERRUN", {
+        buffer: new Uint8Array(bytes),
+        length: length,
+        offset: length + 1
+    });
+    const result = new Uint8Array(length);
+    result.fill(0);
+    if (left) {
+        result.set(bytes, length - bytes.length);
+    }
+    else {
+        result.set(bytes, 0);
+    }
+    return hexlify(result);
+}
+/**
+ *  Return the [[DataHexString]] of %%data%% padded on the **left**
+ *  to %%length%% bytes.
+ *
+ *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is
+ *  thrown.
+ *
+ *  This pads data the same as **values** are in Solidity
+ *  (e.g. ``uint128``).
+ */
+function zeroPadValue(data, length) {
+    return zeroPad(data, length, true);
+}
+
+exports.concat = concat;
+exports.getBytes = getBytes;
+exports.getBytesCopy = getBytesCopy;
+exports.hexlify = hexlify;
+exports.isBytesLike = isBytesLike;
+exports.isHexString = isHexString;
+exports.zeroPadValue = zeroPadValue;

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

@@ -0,0 +1,228 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var properties = require('./properties.js');
+
+/**
+ *  All errors in ethers include properties to ensure they are both
+ *  human-readable (i.e. ``.message``) and machine-readable (i.e. ``.code``).
+ *
+ *  The [[isError]] function can be used to check the error ``code`` and
+ *  provide a type guard for the properties present on that error interface.
+ *
+ *  @_section: api/utils/errors:Errors  [about-errors]
+ */
+function stringify(value) {
+    if (value == null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "[ " + (value.map(stringify)).join(", ") + " ]";
+    }
+    if (value instanceof Uint8Array) {
+        const HEX = "0123456789abcdef";
+        let result = "0x";
+        for (let i = 0; i < value.length; i++) {
+            result += HEX[value[i] >> 4];
+            result += HEX[value[i] & 0xf];
+        }
+        return result;
+    }
+    if (typeof (value) === "object" && typeof (value.toJSON) === "function") {
+        return stringify(value.toJSON());
+    }
+    switch (typeof (value)) {
+        case "boolean":
+        case "symbol":
+            return value.toString();
+        case "bigint":
+            return BigInt(value).toString();
+        case "number":
+            return (value).toString();
+        case "string":
+            return JSON.stringify(value);
+        case "object": {
+            const keys = Object.keys(value);
+            keys.sort();
+            return "{ " + keys.map((k) => `${stringify(k)}: ${stringify(value[k])}`).join(", ") + " }";
+        }
+    }
+    return `[ COULD NOT SERIALIZE ]`;
+}
+/**
+ *  Returns true if the %%error%% matches an error thrown by ethers
+ *  that matches the error %%code%%.
+ *
+ *  In TypeScript environments, this can be used to check that %%error%%
+ *  matches an EthersError type, which means the expected properties will
+ *  be set.
+ *
+ *  @See [ErrorCodes](api:ErrorCode)
+ *  @example
+ *    try {
+ *      // code....
+ *    } catch (e) {
+ *      if (isError(e, "CALL_EXCEPTION")) {
+ *          // The Type Guard has validated this object
+ *          console.log(e.data);
+ *      }
+ *    }
+ */
+function isError(error, code) {
+    return (error && error.code === code);
+}
+/**
+ *  Returns a new Error configured to the format ethers emits errors, with
+ *  the %%message%%, [[api:ErrorCode]] %%code%% and additional properties
+ *  for the corresponding EthersError.
+ *
+ *  Each error in ethers includes the version of ethers, a
+ *  machine-readable [[ErrorCode]], and depending on %%code%%, additional
+ *  required properties. The error message will also include the %%message%%,
+ *  ethers version, %%code%% and all additional properties, serialized.
+ */
+function makeError(message, code, info) {
+    let shortMessage = message;
+    {
+        const details = [];
+        if (info) {
+            if ("message" in info || "code" in info || "name" in info) {
+                throw new Error(`value will overwrite populated values: ${stringify(info)}`);
+            }
+            for (const key in info) {
+                if (key === "shortMessage") {
+                    continue;
+                }
+                const value = (info[key]);
+                //                try {
+                details.push(key + "=" + stringify(value));
+                //                } catch (error: any) {
+                //                console.log("MMM", error.message);
+                //                    details.push(key + "=[could not serialize object]");
+                //                }
+            }
+        }
+        details.push(`code=${code}`);
+        if (details.length) {
+            message += " (" + details.join(", ") + ")";
+        }
+    }
+    let error;
+    switch (code) {
+        case "INVALID_ARGUMENT":
+            error = new TypeError(message);
+            break;
+        case "NUMERIC_FAULT":
+        case "BUFFER_OVERRUN":
+            error = new RangeError(message);
+            break;
+        default:
+            error = new Error(message);
+    }
+    properties.defineProperties(error, { code });
+    if (info) {
+        Object.assign(error, info);
+    }
+    if (error.shortMessage == null) {
+        properties.defineProperties(error, { shortMessage });
+    }
+    return error;
+}
+/**
+ *  Throws an EthersError with %%message%%, %%code%% and additional error
+ *  %%info%% when %%check%% is falsish..
+ *
+ *  @see [[api:makeError]]
+ */
+function assert(check, message, code, info) {
+    if (!check) {
+        throw makeError(message, code, info);
+    }
+}
+/**
+ *  A simple helper to simply ensuring provided arguments match expected
+ *  constraints, throwing if not.
+ *
+ *  In TypeScript environments, the %%check%% has been asserted true, so
+ *  any further code does not need additional compile-time checks.
+ */
+function assertArgument(check, message, name, value) {
+    assert(check, message, "INVALID_ARGUMENT", { argument: name, value: value });
+}
+function assertArgumentCount(count, expectedCount, message) {
+    if (message == null) {
+        message = "";
+    }
+    if (message) {
+        message = ": " + message;
+    }
+    assert(count >= expectedCount, "missing arguemnt" + message, "MISSING_ARGUMENT", {
+        count: count,
+        expectedCount: expectedCount
+    });
+    assert(count <= expectedCount, "too many arguemnts" + message, "UNEXPECTED_ARGUMENT", {
+        count: count,
+        expectedCount: expectedCount
+    });
+}
+const _normalizeForms = ["NFD", "NFC", "NFKD", "NFKC"].reduce((accum, form) => {
+    try {
+        // General test for normalize
+        /* c8 ignore start */
+        if ("test".normalize(form) !== "test") {
+            throw new Error("bad");
+        }
+        ;
+        /* c8 ignore stop */
+        if (form === "NFD") {
+            const check = String.fromCharCode(0xe9).normalize("NFD");
+            const expected = String.fromCharCode(0x65, 0x0301);
+            /* c8 ignore start */
+            if (check !== expected) {
+                throw new Error("broken");
+            }
+            /* c8 ignore stop */
+        }
+        accum.push(form);
+    }
+    catch (error) { }
+    return accum;
+}, []);
+/**
+ *  Throws if the normalization %%form%% is not supported.
+ */
+function assertNormalize(form) {
+    assert(_normalizeForms.indexOf(form) >= 0, "platform missing String.prototype.normalize", "UNSUPPORTED_OPERATION", {
+        operation: "String.prototype.normalize", info: { form }
+    });
+}
+/**
+ *  Many classes use file-scoped values to guard the constructor,
+ *  making it effectively private. This facilitates that pattern
+ *  by ensuring the %%givenGaurd%% matches the file-scoped %%guard%%,
+ *  throwing if not, indicating the %%className%% if provided.
+ */
+function assertPrivate(givenGuard, guard, className) {
+    if (className == null) {
+        className = "";
+    }
+    if (givenGuard !== guard) {
+        let method = className, operation = "new";
+        if (className) {
+            method += ".";
+            operation += " " + className;
+        }
+        assert(false, `private constructor; use ${method}from* methods`, "UNSUPPORTED_OPERATION", {
+            operation
+        });
+    }
+}
+
+exports.assert = assert;
+exports.assertArgument = assertArgument;
+exports.assertArgumentCount = assertArgumentCount;
+exports.assertNormalize = assertNormalize;
+exports.assertPrivate = assertPrivate;
+exports.isError = isError;
+exports.makeError = makeError;

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

@@ -0,0 +1,13 @@
+'use strict';
+
+(undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+(undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};

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

@@ -0,0 +1,29 @@
+'use strict';
+
+require('./errors.js');
+require('./maths.js');
+
+(undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+(undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+BigInt(-1);
+BigInt(0);
+BigInt(1);
+BigInt(5);
+// Constant to pull zeros from for multipliers
+let Zeros = "0000";
+while (Zeros.length < 80) {
+    Zeros += Zeros;
+}
+//const f1 = FixedNumber.fromString("12.56", "fixed16x2");
+//const f2 = FixedNumber.fromString("0.3", "fixed16x2");
+//console.log(f1.divSignal(f2));
+//const BUMP = FixedNumber.from("0.5");

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

@@ -0,0 +1,53 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('./base58.js');
+var errors = require('./errors.js');
+require('./events.js');
+require('./fixednumber.js');
+var maths = require('./maths.js');
+var utf8 = require('./utf8.js');
+require('../../../base/functions/platform.js');
+require('../../../base/functions/encode.js');
+var crypto = require('../../../base/functions/crypto.js');
+var sha3 = require('../../noble-hashes/sha3.js');
+require('../../noble-hashes/sha256.js');
+
+/**
+ *  There are many simple utilities required to interact with
+ *  Ethereum and to simplify the library, without increasing
+ *  the library dependencies for simple functions.
+ *
+ *  @_section api/utils:Utilities  [about-utils]
+ */
+function id(value) {
+    return '0x' + crypto.hash(value, sha3.keccak_256, 'hex');
+}
+function keccak256(value) {
+    return '0x' + crypto.hash(value, sha3.keccak_256, 'hex');
+}
+
+exports.assert = errors.assert;
+exports.assertArgument = errors.assertArgument;
+exports.assertArgumentCount = errors.assertArgumentCount;
+exports.assertNormalize = errors.assertNormalize;
+exports.assertPrivate = errors.assertPrivate;
+exports.isError = errors.isError;
+exports.makeError = errors.makeError;
+exports.fromTwos = maths.fromTwos;
+exports.getBigInt = maths.getBigInt;
+exports.getNumber = maths.getNumber;
+exports.getUint = maths.getUint;
+exports.mask = maths.mask;
+exports.toBeArray = maths.toBeArray;
+exports.toBeHex = maths.toBeHex;
+exports.toBigInt = maths.toBigInt;
+exports.toNumber = maths.toNumber;
+exports.toQuantity = maths.toQuantity;
+exports.toTwos = maths.toTwos;
+exports.Utf8ErrorFuncs = utf8.Utf8ErrorFuncs;
+exports.toUtf8Bytes = utf8.toUtf8Bytes;
+exports.toUtf8String = utf8.toUtf8String;
+exports.id = id;
+exports.keccak256 = keccak256;

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

@@ -0,0 +1,231 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var data = require('./data.js');
+var errors = require('./errors.js');
+
+/**
+ *  Some mathematic operations.
+ *
+ *  @_subsection: api/utils:Math Helpers  [about-maths]
+ */
+const BN_0 = BigInt(0);
+const BN_1 = BigInt(1);
+//const BN_Max256 = (BN_1 << BigInt(256)) - BN_1;
+// IEEE 754 support 53-bits of mantissa
+const maxValue = 0x1fffffffffffff;
+/**
+ *  Convert %%value%% from a twos-compliment representation of %%width%%
+ *  bits to its value.
+ *
+ *  If the highest bit is ``1``, the result will be negative.
+ */
+function fromTwos(_value, _width) {
+    const value = getUint(_value, "value");
+    const width = BigInt(getNumber(_width, "width"));
+    errors.assert((value >> width) === BN_0, "overflow", "NUMERIC_FAULT", {
+        operation: "fromTwos", fault: "overflow", value: _value
+    });
+    // Top bit set; treat as a negative value
+    if (value >> (width - BN_1)) {
+        const mask = (BN_1 << width) - BN_1;
+        return -(((~value) & mask) + BN_1);
+    }
+    return value;
+}
+/**
+ *  Convert %%value%% to a twos-compliment representation of
+ *  %%width%% bits.
+ *
+ *  The result will always be positive.
+ */
+function toTwos(_value, _width) {
+    let value = getBigInt(_value, "value");
+    const width = BigInt(getNumber(_width, "width"));
+    const limit = (BN_1 << (width - BN_1));
+    if (value < BN_0) {
+        value = -value;
+        errors.assert(value <= limit, "too low", "NUMERIC_FAULT", {
+            operation: "toTwos", fault: "overflow", value: _value
+        });
+        const mask = (BN_1 << width) - BN_1;
+        return ((~value) & mask) + BN_1;
+    }
+    else {
+        errors.assert(value < limit, "too high", "NUMERIC_FAULT", {
+            operation: "toTwos", fault: "overflow", value: _value
+        });
+    }
+    return value;
+}
+/**
+ *  Mask %%value%% with a bitmask of %%bits%% ones.
+ */
+function mask(_value, _bits) {
+    const value = getUint(_value, "value");
+    const bits = BigInt(getNumber(_bits, "bits"));
+    return value & ((BN_1 << bits) - BN_1);
+}
+/**
+ *  Gets a BigInt from %%value%%. If it is an invalid value for
+ *  a BigInt, then an ArgumentError will be thrown for %%name%%.
+ */
+function getBigInt(value, name) {
+    switch (typeof (value)) {
+        case "bigint": return value;
+        case "number":
+            errors.assertArgument(Number.isInteger(value), "underflow", name || "value", value);
+            errors.assertArgument(value >= -maxValue && value <= maxValue, "overflow", name || "value", value);
+            return BigInt(value);
+        case "string":
+            try {
+                if (value === "") {
+                    throw new Error("empty string");
+                }
+                if (value[0] === "-" && value[1] !== "-") {
+                    return -BigInt(value.substring(1));
+                }
+                return BigInt(value);
+            }
+            catch (e) {
+                errors.assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || "value", value);
+            }
+    }
+    errors.assertArgument(false, "invalid BigNumberish value", name || "value", value);
+}
+/**
+ *  Returns %%value%% as a bigint, validating it is valid as a bigint
+ *  value and that it is positive.
+ */
+function getUint(value, name) {
+    const result = getBigInt(value, name);
+    errors.assert(result >= BN_0, "unsigned value cannot be negative", "NUMERIC_FAULT", {
+        fault: "overflow", operation: "getUint", value
+    });
+    return result;
+}
+const Nibbles = "0123456789abcdef";
+/*
+ * Converts %%value%% to a BigInt. If %%value%% is a Uint8Array, it
+ * is treated as Big Endian data.
+ */
+function toBigInt(value) {
+    if (value instanceof Uint8Array) {
+        let result = "0x0";
+        for (const v of value) {
+            result += Nibbles[v >> 4];
+            result += Nibbles[v & 0x0f];
+        }
+        return BigInt(result);
+    }
+    return getBigInt(value);
+}
+/**
+ *  Gets a //number// from %%value%%. If it is an invalid value for
+ *  a //number//, then an ArgumentError will be thrown for %%name%%.
+ */
+function getNumber(value, name) {
+    switch (typeof (value)) {
+        case "bigint":
+            errors.assertArgument(value >= -maxValue && value <= maxValue, "overflow", name || "value", value);
+            return Number(value);
+        case "number":
+            errors.assertArgument(Number.isInteger(value), "underflow", name || "value", value);
+            errors.assertArgument(value >= -maxValue && value <= maxValue, "overflow", name || "value", value);
+            return value;
+        case "string":
+            try {
+                if (value === "") {
+                    throw new Error("empty string");
+                }
+                return getNumber(BigInt(value), name);
+            }
+            catch (e) {
+                errors.assertArgument(false, `invalid numeric string: ${e.message}`, name || "value", value);
+            }
+    }
+    errors.assertArgument(false, "invalid numeric value", name || "value", value);
+}
+/**
+ *  Converts %%value%% to a number. If %%value%% is a Uint8Array, it
+ *  is treated as Big Endian data. Throws if the value is not safe.
+ */
+function toNumber(value) {
+    return getNumber(toBigInt(value));
+}
+/**
+ *  Converts %%value%% to a Big Endian hexstring, optionally padded to
+ *  %%width%% bytes.
+ */
+function toBeHex(_value, _width) {
+    const value = getUint(_value, "value");
+    let result = value.toString(16);
+    if (_width == null) {
+        // Ensure the value is of even length
+        if (result.length % 2) {
+            result = "0" + result;
+        }
+    }
+    else {
+        const width = getNumber(_width, "width");
+        errors.assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, "NUMERIC_FAULT", {
+            operation: "toBeHex",
+            fault: "overflow",
+            value: _value
+        });
+        // Pad the value to the required width
+        while (result.length < (width * 2)) {
+            result = "0" + result;
+        }
+    }
+    return "0x" + result;
+}
+/**
+ *  Converts %%value%% to a Big Endian Uint8Array.
+ */
+function toBeArray(_value) {
+    const value = getUint(_value, "value");
+    if (value === BN_0) {
+        return new Uint8Array([]);
+    }
+    let hex = value.toString(16);
+    if (hex.length % 2) {
+        hex = "0" + hex;
+    }
+    const result = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < result.length; i++) {
+        const offset = i * 2;
+        result[i] = parseInt(hex.substring(offset, offset + 2), 16);
+    }
+    return result;
+}
+/**
+ *  Returns a [[HexString]] for %%value%% safe to use as a //Quantity//.
+ *
+ *  A //Quantity// does not have and leading 0 values unless the value is
+ *  the literal value `0x0`. This is most commonly used for JSSON-RPC
+ *  numeric values.
+ */
+function toQuantity(value) {
+    let result = data.hexlify(data.isBytesLike(value) ? value : toBeArray(value)).substring(2);
+    while (result.startsWith("0")) {
+        result = result.substring(1);
+    }
+    if (result === "") {
+        result = "0";
+    }
+    return "0x" + result;
+}
+
+exports.fromTwos = fromTwos;
+exports.getBigInt = getBigInt;
+exports.getNumber = getNumber;
+exports.getUint = getUint;
+exports.mask = mask;
+exports.toBeArray = toBeArray;
+exports.toBeHex = toBeHex;
+exports.toBigInt = toBigInt;
+exports.toNumber = toNumber;
+exports.toQuantity = toQuantity;
+exports.toTwos = toTwos;