ccxt-ir 4.10.0 → 4.12.0

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

@@ -0,0 +1,220 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/**
+ *  Some mathematic operations.
+ *
+ *  @_subsection: api/utils:Math Helpers  [about-maths]
+ */
+import { hexlify, isBytesLike } from "./data.js";
+import { assert, assertArgument } from "./errors.js";
+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.
+ */
+export function fromTwos(_value, _width) {
+    const value = getUint(_value, "value");
+    const width = BigInt(getNumber(_width, "width"));
+    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.
+ */
+export 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;
+        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 {
+        assert(value < limit, "too high", "NUMERIC_FAULT", {
+            operation: "toTwos", fault: "overflow", value: _value
+        });
+    }
+    return value;
+}
+/**
+ *  Mask %%value%% with a bitmask of %%bits%% ones.
+ */
+export 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%%.
+ */
+export function getBigInt(value, name) {
+    switch (typeof (value)) {
+        case "bigint": return value;
+        case "number":
+            assertArgument(Number.isInteger(value), "underflow", name || "value", value);
+            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) {
+                assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || "value", value);
+            }
+    }
+    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.
+ */
+export function getUint(value, name) {
+    const result = getBigInt(value, name);
+    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.
+ */
+export 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%%.
+ */
+export function getNumber(value, name) {
+    switch (typeof (value)) {
+        case "bigint":
+            assertArgument(value >= -maxValue && value <= maxValue, "overflow", name || "value", value);
+            return Number(value);
+        case "number":
+            assertArgument(Number.isInteger(value), "underflow", name || "value", value);
+            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) {
+                assertArgument(false, `invalid numeric string: ${e.message}`, name || "value", value);
+            }
+    }
+    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.
+ */
+export function toNumber(value) {
+    return getNumber(toBigInt(value));
+}
+/**
+ *  Converts %%value%% to a Big Endian hexstring, optionally padded to
+ *  %%width%% bytes.
+ */
+export 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");
+        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.
+ */
+export 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.
+ */
+export function toQuantity(value) {
+    let result = hexlify(isBytesLike(value) ? value : toBeArray(value)).substring(2);
+    while (result.startsWith("0")) {
+        result = result.substring(1);
+    }
+    if (result === "") {
+        result = "0";
+    }
+    return "0x" + result;
+}

package/js/src/src/static_dependencies/ethers/utils/properties.d.ts

@@ -0,0 +1,22 @@
+/**
+ *  Property helper functions.
+ *
+ *  @_subsection api/utils:Properties  [about-properties]
+ */
+/**
+ *  Resolves to a new object that is a copy of %%value%%, but with all
+ *  values resolved.
+ */
+export declare function resolveProperties<T>(value: {
+    [P in keyof T]: T[P] | Promise<T[P]>;
+}): Promise<T>;
+/**
+ *  Assigns the %%values%% to %%target%% as read-only values.
+ *
+ *  It %%types%% is specified, the values are checked.
+ */
+export declare function defineProperties<T>(target: T, values: {
+    [K in keyof T]?: T[K];
+}, types?: {
+    [K in keyof T]?: string;
+}): void;

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

@@ -0,0 +1,59 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/**
+ *  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;
+}
+/**
+ *  Resolves to a new object that is a copy of %%value%%, but with all
+ *  values resolved.
+ */
+export async function resolveProperties(value) {
+    const keys = Object.keys(value);
+    const results = await Promise.all(keys.map((k) => Promise.resolve(value[k])));
+    return results.reduce((accum, v, index) => {
+        accum[keys[index]] = v;
+        return accum;
+    }, {});
+}
+/**
+ *  Assigns the %%values%% to %%target%% as read-only values.
+ *
+ *  It %%types%% is specified, the values are checked.
+ */
+export 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 });
+    }
+}

package/js/src/src/static_dependencies/ethers/utils/rlp-decode.d.ts

@@ -0,0 +1,5 @@
+import type { BytesLike, RlpStructuredData } from "./index.js";
+/**
+ *  Decodes %%data%% into the structured data it represents.
+ */
+export declare function decodeRlp(_data: BytesLike): RlpStructuredData;

package/js/src/src/static_dependencies/ethers/utils/rlp-decode.js

@@ -0,0 +1,84 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+//See: https://github.com/ethereum/wiki/wiki/RLP
+import { hexlify } from "./data.js";
+import { assert, assertArgument } from "./errors.js";
+import { getBytes } from "./data.js";
+function hexlifyByte(value) {
+    let result = value.toString(16);
+    while (result.length < 2) {
+        result = "0" + result;
+    }
+    return "0x" + result;
+}
+function unarrayifyInteger(data, offset, length) {
+    let result = 0;
+    for (let i = 0; i < length; i++) {
+        result = (result * 256) + data[offset + i];
+    }
+    return result;
+}
+function _decodeChildren(data, offset, childOffset, length) {
+    const result = [];
+    while (childOffset < offset + 1 + length) {
+        const decoded = _decode(data, childOffset);
+        result.push(decoded.result);
+        childOffset += decoded.consumed;
+        assert(childOffset <= offset + 1 + length, "child data too short", "BUFFER_OVERRUN", {
+            buffer: data, length, offset
+        });
+    }
+    return { consumed: (1 + length), result: result };
+}
+// returns { consumed: number, result: Object }
+function _decode(data, offset) {
+    assert(data.length !== 0, "data too short", "BUFFER_OVERRUN", {
+        buffer: data, length: 0, offset: 1
+    });
+    const checkOffset = (offset) => {
+        assert(offset <= data.length, "data short segment too short", "BUFFER_OVERRUN", {
+            buffer: data, length: data.length, offset
+        });
+    };
+    // Array with extra length prefix
+    if (data[offset] >= 0xf8) {
+        const lengthLength = data[offset] - 0xf7;
+        checkOffset(offset + 1 + lengthLength);
+        const length = unarrayifyInteger(data, offset + 1, lengthLength);
+        checkOffset(offset + 1 + lengthLength + length);
+        return _decodeChildren(data, offset, offset + 1 + lengthLength, lengthLength + length);
+    }
+    else if (data[offset] >= 0xc0) {
+        const length = data[offset] - 0xc0;
+        checkOffset(offset + 1 + length);
+        return _decodeChildren(data, offset, offset + 1, length);
+    }
+    else if (data[offset] >= 0xb8) {
+        const lengthLength = data[offset] - 0xb7;
+        checkOffset(offset + 1 + lengthLength);
+        const length = unarrayifyInteger(data, offset + 1, lengthLength);
+        checkOffset(offset + 1 + lengthLength + length);
+        const result = hexlify(data.slice(offset + 1 + lengthLength, offset + 1 + lengthLength + length));
+        return { consumed: (1 + lengthLength + length), result: result };
+    }
+    else if (data[offset] >= 0x80) {
+        const length = data[offset] - 0x80;
+        checkOffset(offset + 1 + length);
+        const result = hexlify(data.slice(offset + 1, offset + 1 + length));
+        return { consumed: (1 + length), result: result };
+    }
+    return { consumed: 1, result: hexlifyByte(data[offset]) };
+}
+/**
+ *  Decodes %%data%% into the structured data it represents.
+ */
+export function decodeRlp(_data) {
+    const data = getBytes(_data, "data");
+    const decoded = _decode(data, 0);
+    assertArgument(decoded.consumed === data.length, "unexpected junk after rlp payload", "data", _data);
+    return decoded.result;
+}

package/js/src/src/static_dependencies/ethers/utils/rlp-encode.d.ts

@@ -0,0 +1,5 @@
+import type { RlpStructuredDataish } from "./rlp.js";
+/**
+ *  Encodes %%object%% as an RLP-encoded [[DataHexString]].
+ */
+export declare function encodeRlp(object: RlpStructuredDataish): string;

package/js/src/src/static_dependencies/ethers/utils/rlp-encode.js

@@ -0,0 +1,54 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+//See: https://github.com/ethereum/wiki/wiki/RLP
+import { getBytes } from "./data.js";
+function arrayifyInteger(value) {
+    const result = [];
+    while (value) {
+        result.unshift(value & 0xff);
+        value >>= 8;
+    }
+    return result;
+}
+function _encode(object) {
+    if (Array.isArray(object)) {
+        let payload = [];
+        object.forEach(function (child) {
+            payload = payload.concat(_encode(child));
+        });
+        if (payload.length <= 55) {
+            payload.unshift(0xc0 + payload.length);
+            return payload;
+        }
+        const length = arrayifyInteger(payload.length);
+        length.unshift(0xf7 + length.length);
+        return length.concat(payload);
+    }
+    const data = Array.prototype.slice.call(getBytes(object, "object"));
+    if (data.length === 1 && data[0] <= 0x7f) {
+        return data;
+    }
+    else if (data.length <= 55) {
+        data.unshift(0x80 + data.length);
+        return data;
+    }
+    const length = arrayifyInteger(data.length);
+    length.unshift(0xb7 + length.length);
+    return length.concat(data);
+}
+const nibbles = "0123456789abcdef";
+/**
+ *  Encodes %%object%% as an RLP-encoded [[DataHexString]].
+ */
+export function encodeRlp(object) {
+    let result = "0x";
+    for (const v of _encode(object)) {
+        result += nibbles[v >> 4];
+        result += nibbles[v & 0xf];
+    }
+    return result;
+}

package/js/src/src/static_dependencies/ethers/utils/rlp.d.ts

@@ -0,0 +1,16 @@
+/**
+ *  The [[link-rlp]] (RLP) encoding is used throughout Ethereum
+ *  to serialize nested structures of Arrays and data.
+ *
+ *  @_subsection api/utils:Recursive-Length Prefix  [about-rlp]
+ */
+export { decodeRlp } from "./rlp-decode.js";
+export { encodeRlp } from "./rlp-encode.js";
+/**
+ *  An RLP-encoded structure.
+ */
+export declare type RlpStructuredData = string | Array<RlpStructuredData>;
+/**
+ *  An RLP-encoded structure, which allows Uint8Array.
+ */
+export declare type RlpStructuredDataish = string | Uint8Array | Array<RlpStructuredDataish>;

package/js/src/src/static_dependencies/ethers/utils/rlp.js

@@ -0,0 +1,14 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/**
+ *  The [[link-rlp]] (RLP) encoding is used throughout Ethereum
+ *  to serialize nested structures of Arrays and data.
+ *
+ *  @_subsection api/utils:Recursive-Length Prefix  [about-rlp]
+ */
+export { decodeRlp } from "./rlp-decode.js";
+export { encodeRlp } from "./rlp-encode.js";

package/js/src/src/static_dependencies/ethers/utils/units.d.ts

@@ -0,0 +1,23 @@
+import type { BigNumberish, Numeric } from "../utils/index.js";
+/**
+ *  Converts %%value%% into a //decimal string//, assuming %%unit%% decimal
+ *  places. The %%unit%% may be the number of decimal places or the name of
+ *  a unit (e.g. ``"gwei"`` for 9 decimal places).
+ *
+ */
+export declare function formatUnits(value: BigNumberish, unit?: string | Numeric): string;
+/**
+ *  Converts the //decimal string// %%value%% to a BigInt, assuming
+ *  %%unit%% decimal places. The %%unit%% may the number of decimal places
+ *  or the name of a unit (e.g. ``"gwei"`` for 9 decimal places).
+ */
+export declare function parseUnits(value: string, unit?: string | Numeric): bigint;
+/**
+ *  Converts %%value%% into a //decimal string// using 18 decimal places.
+ */
+export declare function formatEther(wei: BigNumberish): string;
+/**
+ *  Converts the //decimal string// %%ether%% to a BigInt, using 18
+ *  decimal places.
+ */
+export declare function parseEther(ether: string): bigint;

package/js/src/src/static_dependencies/ethers/utils/units.js

@@ -0,0 +1,88 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/**
+ *  Most interactions with Ethereum requires integer values, which use
+ *  the smallest magnitude unit.
+ *
+ *  For example, imagine dealing with dollars and cents. Since dollars
+ *  are divisible, non-integer values are possible, such as ``$10.77``.
+ *  By using the smallest indivisible unit (i.e. cents), the value can
+ *  be kept as the integer ``1077``.
+ *
+ *  When receiving decimal input from the user (as a decimal string),
+ *  the value should be converted to an integer and when showing a user
+ *  a value, the integer value should be converted to a decimal string.
+ *
+ *  This creates a clear distinction, between values to be used by code
+ *  (integers) and values used for display logic to users (decimals).
+ *
+ *  The native unit in Ethereum, //ether// is divisible to 18 decimal places,
+ *  where each individual unit is called a //wei//.
+ *
+ *  @_subsection api/utils:Unit Conversion  [about-units]
+ */
+import { assertArgument } from "./errors.js";
+import { FixedNumber } from "./fixednumber.js";
+import { getNumber } from "./maths.js";
+const names = [
+    "wei",
+    "kwei",
+    "mwei",
+    "gwei",
+    "szabo",
+    "finney",
+    "ether",
+];
+/**
+ *  Converts %%value%% into a //decimal string//, assuming %%unit%% decimal
+ *  places. The %%unit%% may be the number of decimal places or the name of
+ *  a unit (e.g. ``"gwei"`` for 9 decimal places).
+ *
+ */
+export function formatUnits(value, unit) {
+    let decimals = 18;
+    if (typeof (unit) === "string") {
+        const index = names.indexOf(unit);
+        assertArgument(index >= 0, "invalid unit", "unit", unit);
+        decimals = 3 * index;
+    }
+    else if (unit != null) {
+        decimals = getNumber(unit, "unit");
+    }
+    return FixedNumber.fromValue(value, decimals, { decimals, width: 512 }).toString();
+}
+/**
+ *  Converts the //decimal string// %%value%% to a BigInt, assuming
+ *  %%unit%% decimal places. The %%unit%% may the number of decimal places
+ *  or the name of a unit (e.g. ``"gwei"`` for 9 decimal places).
+ */
+export function parseUnits(value, unit) {
+    assertArgument(typeof (value) === "string", "value must be a string", "value", value);
+    let decimals = 18;
+    if (typeof (unit) === "string") {
+        const index = names.indexOf(unit);
+        assertArgument(index >= 0, "invalid unit", "unit", unit);
+        decimals = 3 * index;
+    }
+    else if (unit != null) {
+        decimals = getNumber(unit, "unit");
+    }
+    return FixedNumber.fromString(value, { decimals, width: 512 }).value;
+}
+/**
+ *  Converts %%value%% into a //decimal string// using 18 decimal places.
+ */
+export function formatEther(wei) {
+    return formatUnits(wei, 18);
+}
+/**
+ *  Converts the //decimal string// %%ether%% to a BigInt, using 18
+ *  decimal places.
+ */
+export function parseEther(ether) {
+    return parseUnits(ether, 18);
+}