ccxt 4.2.59 → 4.2.61

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

@@ -0,0 +1,227 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+/**
+ *  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]
+ */
+import { defineProperties } from "./properties.js";
+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);
+ *      }
+ *    }
+ */
+export function isError(error, code) {
+    return (error && error.code === code);
+}
+/**
+ *  Returns true if %%error%% is a [[CallExceptionError].
+ */
+export function isCallException(error) {
+    return isError(error, "CALL_EXCEPTION");
+}
+/**
+ *  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.
+ */
+export 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);
+    }
+    defineProperties(error, { code });
+    if (info) {
+        Object.assign(error, info);
+    }
+    if (error.shortMessage == null) {
+        defineProperties(error, { shortMessage });
+    }
+    return error;
+}
+/**
+ *  Throws an EthersError with %%message%%, %%code%% and additional error
+ *  %%info%% when %%check%% is falsish..
+ *
+ *  @see [[api:makeError]]
+ */
+export 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.
+ */
+export function assertArgument(check, message, name, value) {
+    assert(check, message, "INVALID_ARGUMENT", { argument: name, value: value });
+}
+export 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.
+ */
+export 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.
+ */
+export 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
+        });
+    }
+}

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

@@ -0,0 +1,76 @@
+/**
+ *  A callback function called when a an event is triggered.
+ */
+export declare type Listener = (...args: Array<any>) => void;
+/**
+ *  An **EventEmitterable** behaves similar to an EventEmitter
+ *  except provides async access to its methods.
+ *
+ *  An EventEmitter implements the observer pattern.
+ */
+export interface EventEmitterable<T> {
+    /**
+     *  Registers a %%listener%% that is called whenever the
+     *  %%event%% occurs until unregistered.
+     */
+    on(event: T, listener: Listener): Promise<this>;
+    /**
+     *  Registers a %%listener%% that is called the next time
+     *  %%event%% occurs.
+     */
+    once(event: T, listener: Listener): Promise<this>;
+    /**
+     *  Triggers each listener for %%event%% with the %%args%%.
+     */
+    emit(event: T, ...args: Array<any>): Promise<boolean>;
+    /**
+     *  Resolves to the number of listeners for %%event%%.
+     */
+    listenerCount(event?: T): Promise<number>;
+    /**
+     *  Resolves to the listeners for %%event%%.
+     */
+    listeners(event?: T): Promise<Array<Listener>>;
+    /**
+     *  Unregister the %%listener%% for %%event%%. If %%listener%%
+     *  is unspecified, all listeners are unregistered.
+     */
+    off(event: T, listener?: Listener): Promise<this>;
+    /**
+     *  Unregister all listeners for %%event%%.
+     */
+    removeAllListeners(event?: T): Promise<this>;
+    /**
+     *  Alias for [[on]].
+     */
+    addListener(event: T, listener: Listener): Promise<this>;
+    /**
+     *  Alias for [[off]].
+     */
+    removeListener(event: T, listener: Listener): Promise<this>;
+}
+/**
+ *  When an [[EventEmitterable]] triggers a [[Listener]], the
+ *  callback always ahas one additional argument passed, which is
+ *  an **EventPayload**.
+ */
+export declare class EventPayload<T> {
+    #private;
+    /**
+     *  The event filter.
+     */
+    readonly filter: T;
+    /**
+     *  The **EventEmitterable**.
+     */
+    readonly emitter: EventEmitterable<T>;
+    /**
+     *  Create a new **EventPayload** for %%emitter%% with
+     *  the %%listener%% and for %%filter%%.
+     */
+    constructor(emitter: EventEmitterable<T>, listener: null | Listener, filter: T);
+    /**
+     *  Unregister the triggered listener for future events.
+     */
+    removeListener(): Promise<void>;
+}

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

@@ -0,0 +1,52 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+var __classPrivateFieldSet = (this && this.__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;
+};
+var __classPrivateFieldGet = (this && this.__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);
+};
+var _EventPayload_listener;
+/**
+ *  Events allow for applications to use the observer pattern, which
+ *  allows subscribing and publishing events, outside the normal
+ *  execution paths.
+ *
+ *  @_section api/utils/events:Events  [about-events]
+ */
+import { defineProperties } from "./properties.js";
+/**
+ *  When an [[EventEmitterable]] triggers a [[Listener]], the
+ *  callback always ahas one additional argument passed, which is
+ *  an **EventPayload**.
+ */
+export class EventPayload {
+    /**
+     *  Create a new **EventPayload** for %%emitter%% with
+     *  the %%listener%% and for %%filter%%.
+     */
+    constructor(emitter, listener, filter) {
+        _EventPayload_listener.set(this, void 0);
+        __classPrivateFieldSet(this, _EventPayload_listener, listener, "f");
+        defineProperties(this, { emitter, filter });
+    }
+    /**
+     *  Unregister the triggered listener for future events.
+     */
+    async removeListener() {
+        if (__classPrivateFieldGet(this, _EventPayload_listener, "f") == null) {
+            return;
+        }
+        await this.emitter.off(this.filter, __classPrivateFieldGet(this, _EventPayload_listener, "f"));
+    }
+}
+_EventPayload_listener = new WeakMap();

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

@@ -0,0 +1,251 @@
+import type { BigNumberish, BytesLike, Numeric } from "./index.js";
+/**
+ *  A description of a fixed-point arithmetic field.
+ *
+ *  When specifying the fixed format, the values override the default of
+ *  a ``fixed128x18``, which implies a signed 128-bit value with 18
+ *  decimals of precision.
+ *
+ *  The alias ``fixed`` and ``ufixed`` can be used for ``fixed128x18`` and
+ *  ``ufixed128x18`` respectively.
+ *
+ *  When a fixed format string begins with a ``u``, it indicates the field
+ *  is unsigned, so any negative values will overflow. The first number
+ *  indicates the bit-width and the second number indicates the decimal
+ *  precision.
+ *
+ *  When a ``number`` is used for a fixed format, it indicates the number
+ *  of decimal places, and the default width and signed-ness will be used.
+ *
+ *  The bit-width must be byte aligned and the decimals can be at most 80.
+ */
+export declare type FixedFormat = number | string | {
+    signed?: boolean;
+    width?: number;
+    decimals?: number;
+};
+/**
+ *  A FixedNumber represents a value over its [[FixedFormat]]
+ *  arithmetic field.
+ *
+ *  A FixedNumber can be used to perform math, losslessly, on
+ *  values which have decmial places.
+ *
+ *  A FixedNumber has a fixed bit-width to store values in, and stores all
+ *  values internally by multiplying the value by 10 raised to the power of
+ *  %%decimals%%.
+ *
+ *  If operations are performed that cause a value to grow too high (close to
+ *  positive infinity) or too low (close to negative infinity), the value
+ *  is said to //overflow//.
+ *
+ *  For example, an 8-bit signed value, with 0 decimals may only be within
+ *  the range ``-128`` to ``127``; so ``-128 - 1`` will overflow and become
+ *  ``127``. Likewise, ``127 + 1`` will overflow and become ``-127``.
+ *
+ *  Many operation have a normal and //unsafe// variant. The normal variant
+ *  will throw a [[NumericFaultError]] on any overflow, while the //unsafe//
+ *  variant will silently allow overflow, corrupting its value value.
+ *
+ *  If operations are performed that cause a value to become too small
+ *  (close to zero), the value loses precison and is said to //underflow//.
+ *
+ *  For example, an value with 1 decimal place may store a number as small
+ *  as ``0.1``, but the value of ``0.1 / 2`` is ``0.05``, which cannot fit
+ *  into 1 decimal place, so underflow occurs which means precision is lost
+ *  and the value becomes ``0``.
+ *
+ *  Some operations have a normal and //signalling// variant. The normal
+ *  variant will silently ignore underflow, while the //signalling// variant
+ *  will thow a [[NumericFaultError]] on underflow.
+ */
+export declare class FixedNumber {
+    #private;
+    /**
+     *  The specific fixed-point arithmetic field for this value.
+     */
+    readonly format: string;
+    /**
+     *  This is a property so console.log shows a human-meaningful value.
+     *
+     *  @private
+     */
+    readonly _value: string;
+    /**
+     *  @private
+     */
+    constructor(guard: any, value: bigint, format: any);
+    /**
+     *  If true, negative values are permitted, otherwise only
+     *  positive values and zero are allowed.
+     */
+    get signed(): boolean;
+    /**
+     *  The number of bits available to store the value.
+     */
+    get width(): number;
+    /**
+     *  The number of decimal places in the fixed-point arithment field.
+     */
+    get decimals(): number;
+    /**
+     *  The value as an integer, based on the smallest unit the
+     *  [[decimals]] allow.
+     */
+    get value(): bigint;
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% added
+     *  to %%other%%, ignoring overflow.
+     */
+    addUnsafe(other: FixedNumber): FixedNumber;
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% added
+     *  to %%other%%. A [[NumericFaultError]] is thrown if overflow
+     *  occurs.
+     */
+    add(other: FixedNumber): FixedNumber;
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%other%% subtracted
+     *  from %%this%%, ignoring overflow.
+     */
+    subUnsafe(other: FixedNumber): FixedNumber;
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%other%% subtracted
+     *  from %%this%%. A [[NumericFaultError]] is thrown if overflow
+     *  occurs.
+     */
+    sub(other: FixedNumber): FixedNumber;
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
+     *  by %%other%%, ignoring overflow and underflow (precision loss).
+     */
+    mulUnsafe(other: FixedNumber): FixedNumber;
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
+     *  by %%other%%. A [[NumericFaultError]] is thrown if overflow
+     *  occurs.
+     */
+    mul(other: FixedNumber): FixedNumber;
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
+     *  by %%other%%. A [[NumericFaultError]] is thrown if overflow
+     *  occurs or if underflow (precision loss) occurs.
+     */
+    mulSignal(other: FixedNumber): FixedNumber;
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% divided
+     *  by %%other%%, ignoring underflow (precision loss). A
+     *  [[NumericFaultError]] is thrown if overflow occurs.
+     */
+    divUnsafe(other: FixedNumber): FixedNumber;
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% divided
+     *  by %%other%%, ignoring underflow (precision loss). A
+     *  [[NumericFaultError]] is thrown if overflow occurs.
+     */
+    div(other: FixedNumber): FixedNumber;
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% divided
+     *  by %%other%%. A [[NumericFaultError]] is thrown if underflow
+     *  (precision loss) occurs.
+     */
+    divSignal(other: FixedNumber): FixedNumber;
+    /**
+     *  Returns a comparison result between %%this%% and %%other%%.
+     *
+     *  This is suitable for use in sorting, where ``-1`` implies %%this%%
+     *  is smaller, ``1`` implies %%this%% is larger and ``0`` implies
+     *  both are equal.
+     */
+    cmp(other: FixedNumber): number;
+    /**
+     *  Returns true if %%other%% is equal to %%this%%.
+     */
+    eq(other: FixedNumber): boolean;
+    /**
+     *  Returns true if %%other%% is less than to %%this%%.
+     */
+    lt(other: FixedNumber): boolean;
+    /**
+     *  Returns true if %%other%% is less than or equal to %%this%%.
+     */
+    lte(other: FixedNumber): boolean;
+    /**
+     *  Returns true if %%other%% is greater than to %%this%%.
+     */
+    gt(other: FixedNumber): boolean;
+    /**
+     *  Returns true if %%other%% is greater than or equal to %%this%%.
+     */
+    gte(other: FixedNumber): boolean;
+    /**
+     *  Returns a new [[FixedNumber]] which is the largest **integer**
+     *  that is less than or equal to %%this%%.
+     *
+     *  The decimal component of the result will always be ``0``.
+     */
+    floor(): FixedNumber;
+    /**
+     *  Returns a new [[FixedNumber]] which is the smallest **integer**
+     *  that is greater than or equal to %%this%%.
+     *
+     *  The decimal component of the result will always be ``0``.
+     */
+    ceiling(): FixedNumber;
+    /**
+     *  Returns a new [[FixedNumber]] with the decimal component
+     *  rounded up on ties at %%decimals%% places.
+     */
+    round(decimals?: number): FixedNumber;
+    /**
+     *  Returns true if %%this%% is equal to ``0``.
+     */
+    isZero(): boolean;
+    /**
+     *  Returns true if %%this%% is less than ``0``.
+     */
+    isNegative(): boolean;
+    /**
+     *  Returns the string representation of %%this%%.
+     */
+    toString(): string;
+    /**
+     *  Returns a float approximation.
+     *
+     *  Due to IEEE 754 precission (or lack thereof), this function
+     *  can only return an approximation and most values will contain
+     *  rounding errors.
+     */
+    toUnsafeFloat(): number;
+    /**
+     *  Return a new [[FixedNumber]] with the same value but has had
+     *  its field set to %%format%%.
+     *
+     *  This will throw if the value cannot fit into %%format%%.
+     */
+    toFormat(format: FixedFormat): FixedNumber;
+    /**
+     *  Creates a new [[FixedNumber]] for %%value%% divided by
+     *  %%decimal%% places with %%format%%.
+     *
+     *  This will throw a [[NumericFaultError]] if %%value%% (once adjusted
+     *  for %%decimals%%) cannot fit in %%format%%, either due to overflow
+     *  or underflow (precision loss).
+     */
+    static fromValue(_value: BigNumberish, _decimals?: Numeric, _format?: FixedFormat): FixedNumber;
+    /**
+     *  Creates a new [[FixedNumber]] for %%value%% with %%format%%.
+     *
+     *  This will throw a [[NumericFaultError]] if %%value%% cannot fit
+     *  in %%format%%, either due to overflow or underflow (precision loss).
+     */
+    static fromString(_value: string, _format?: FixedFormat): FixedNumber;
+    /**
+     *  Creates a new [[FixedNumber]] with the big-endian representation
+     *  %%value%% with %%format%%.
+     *
+     *  This will throw a [[NumericFaultError]] if %%value%% cannot fit
+     *  in %%format%% due to overflow.
+     */
+    static fromBytes(_value: BytesLike, _format?: FixedFormat): FixedNumber;
+}