ccxt 4.2.60 → 4.2.61

package/js/src/static_dependencies/ethers/coders/array.js

@@ -0,0 +1,162 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+import { defineProperties, isError, assert, assertArgument, assertArgumentCount } from "../utils/index.js";
+import { Typed } from "../typed.js";
+import { Coder, Result, WordSize, Writer } from "./abstract-coder.js";
+import { AnonymousCoder } from "./anonymous.js";
+/**
+ *  @_ignore
+ */
+export function pack(writer, coders, values) {
+    let arrayValues = [];
+    if (Array.isArray(values)) {
+        arrayValues = values;
+    }
+    else if (values && typeof (values) === "object") {
+        let unique = {};
+        arrayValues = coders.map((coder) => {
+            const name = coder.localName;
+            assert(name, "cannot encode object for signature with missing names", "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });
+            assert(!unique[name], "cannot encode object for signature with duplicate names", "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });
+            unique[name] = true;
+            return values[name];
+        });
+    }
+    else {
+        assertArgument(false, "invalid tuple value", "tuple", values);
+    }
+    assertArgument(coders.length === arrayValues.length, "types/value length mismatch", "tuple", values);
+    let staticWriter = new Writer();
+    let dynamicWriter = new Writer();
+    let updateFuncs = [];
+    coders.forEach((coder, index) => {
+        let value = arrayValues[index];
+        if (coder.dynamic) {
+            // Get current dynamic offset (for the future pointer)
+            let dynamicOffset = dynamicWriter.length;
+            // Encode the dynamic value into the dynamicWriter
+            coder.encode(dynamicWriter, value);
+            // Prepare to populate the correct offset once we are done
+            let updateFunc = staticWriter.writeUpdatableValue();
+            updateFuncs.push((baseOffset) => {
+                updateFunc(baseOffset + dynamicOffset);
+            });
+        }
+        else {
+            coder.encode(staticWriter, value);
+        }
+    });
+    // Backfill all the dynamic offsets, now that we know the static length
+    updateFuncs.forEach((func) => { func(staticWriter.length); });
+    let length = writer.appendWriter(staticWriter);
+    length += writer.appendWriter(dynamicWriter);
+    return length;
+}
+/**
+ *  @_ignore
+ */
+export function unpack(reader, coders) {
+    let values = [];
+    let keys = [];
+    // A reader anchored to this base
+    let baseReader = reader.subReader(0);
+    coders.forEach((coder) => {
+        let value = null;
+        if (coder.dynamic) {
+            let offset = reader.readIndex();
+            let offsetReader = baseReader.subReader(offset);
+            try {
+                value = coder.decode(offsetReader);
+            }
+            catch (error) {
+                // Cannot recover from this
+                if (isError(error, "BUFFER_OVERRUN")) {
+                    throw error;
+                }
+                value = error;
+                value.baseType = coder.name;
+                value.name = coder.localName;
+                value.type = coder.type;
+            }
+        }
+        else {
+            try {
+                value = coder.decode(reader);
+            }
+            catch (error) {
+                // Cannot recover from this
+                if (isError(error, "BUFFER_OVERRUN")) {
+                    throw error;
+                }
+                value = error;
+                value.baseType = coder.name;
+                value.name = coder.localName;
+                value.type = coder.type;
+            }
+        }
+        if (value == undefined) {
+            throw new Error("investigate");
+        }
+        values.push(value);
+        keys.push(coder.localName || null);
+    });
+    return Result.fromItems(values, keys);
+}
+/**
+ *  @_ignore
+ */
+export class ArrayCoder extends Coder {
+    constructor(coder, length, localName) {
+        const type = (coder.type + "[" + (length >= 0 ? length : "") + "]");
+        const dynamic = (length === -1 || coder.dynamic);
+        super("array", type, localName, dynamic);
+        defineProperties(this, { coder, length });
+    }
+    defaultValue() {
+        // Verifies the child coder is valid (even if the array is dynamic or 0-length)
+        const defaultChild = this.coder.defaultValue();
+        const result = [];
+        for (let i = 0; i < this.length; i++) {
+            result.push(defaultChild);
+        }
+        return result;
+    }
+    encode(writer, _value) {
+        const value = Typed.dereference(_value, "array");
+        if (!Array.isArray(value)) {
+            this._throwError("expected array value", value);
+        }
+        let count = this.length;
+        if (count === -1) {
+            count = value.length;
+            writer.writeValue(value.length);
+        }
+        assertArgumentCount(value.length, count, "coder array" + (this.localName ? (" " + this.localName) : ""));
+        let coders = [];
+        for (let i = 0; i < value.length; i++) {
+            coders.push(this.coder);
+        }
+        return pack(writer, coders, value);
+    }
+    decode(reader) {
+        let count = this.length;
+        if (count === -1) {
+            count = reader.readIndex();
+            // Check that there is *roughly* enough data to ensure
+            // stray random data is not being read as a length. Each
+            // slot requires at least 32 bytes for their value (or 32
+            // bytes as a link to the data). This could use a much
+            // tighter bound, but we are erroring on the side of safety.
+            assert(count * WordSize <= reader.dataLength, "insufficient data length", "BUFFER_OVERRUN", { buffer: reader.bytes, offset: count * WordSize, length: reader.dataLength });
+        }
+        let coders = [];
+        for (let i = 0; i < count; i++) {
+            coders.push(new AnonymousCoder(this.coder));
+        }
+        return unpack(reader, coders);
+    }
+}

package/js/src/static_dependencies/ethers/coders/boolean.d.ts

@@ -0,0 +1,12 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class BooleanCoder extends Coder {
+    constructor(localName: string);
+    defaultValue(): boolean;
+    encode(writer: Writer, _value: boolean | Typed): number;
+    decode(reader: Reader): any;
+}

package/js/src/static_dependencies/ethers/coders/boolean.js

@@ -0,0 +1,26 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export class BooleanCoder extends Coder {
+    constructor(localName) {
+        super("bool", "bool", localName, false);
+    }
+    defaultValue() {
+        return false;
+    }
+    encode(writer, _value) {
+        const value = Typed.dereference(_value, "bool");
+        return writer.writeValue(value ? 1 : 0);
+    }
+    decode(reader) {
+        return !!reader.readValue();
+    }
+}

package/js/src/static_dependencies/ethers/coders/bytes.d.ts

@@ -0,0 +1,18 @@
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class DynamicBytesCoder extends Coder {
+    constructor(type: string, localName: string);
+    defaultValue(): string;
+    encode(writer: Writer, value: any): number;
+    decode(reader: Reader): any;
+}
+/**
+ *  @_ignore
+ */
+export declare class BytesCoder extends DynamicBytesCoder {
+    constructor(localName: string);
+    decode(reader: Reader): any;
+}

package/js/src/static_dependencies/ethers/coders/bytes.js

@@ -0,0 +1,39 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+import { getBytesCopy, hexlify } from "../utils/index.js";
+import { Coder } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export class DynamicBytesCoder extends Coder {
+    constructor(type, localName) {
+        super(type, type, localName, true);
+    }
+    defaultValue() {
+        return "0x";
+    }
+    encode(writer, value) {
+        value = getBytesCopy(value);
+        let length = writer.writeValue(value.length);
+        length += writer.writeBytes(value);
+        return length;
+    }
+    decode(reader) {
+        return reader.readBytes(reader.readIndex(), true);
+    }
+}
+/**
+ *  @_ignore
+ */
+export class BytesCoder extends DynamicBytesCoder {
+    constructor(localName) {
+        super("bytes", localName);
+    }
+    decode(reader) {
+        return hexlify(super.decode(reader));
+    }
+}

package/js/src/static_dependencies/ethers/coders/fixed-bytes.d.ts

@@ -0,0 +1,14 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { BytesLike } from "../utils/index.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class FixedBytesCoder extends Coder {
+    readonly size: number;
+    constructor(size: number, localName: string);
+    defaultValue(): string;
+    encode(writer: Writer, _value: BytesLike | Typed): number;
+    decode(reader: Reader): any;
+}

package/js/src/static_dependencies/ethers/coders/fixed-bytes.js

@@ -0,0 +1,32 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+import { defineProperties, getBytesCopy, hexlify } from "../utils/index.js";
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export class FixedBytesCoder extends Coder {
+    constructor(size, localName) {
+        let name = "bytes" + String(size);
+        super(name, name, localName, false);
+        defineProperties(this, { size }, { size: "number" });
+    }
+    defaultValue() {
+        return ("0x0000000000000000000000000000000000000000000000000000000000000000").substring(0, 2 + this.size * 2);
+    }
+    encode(writer, _value) {
+        let data = getBytesCopy(Typed.dereference(_value, this.type));
+        if (data.length !== this.size) {
+            this._throwError("incorrect data length", _value);
+        }
+        return writer.writeBytes(data);
+    }
+    decode(reader) {
+        return hexlify(reader.readBytes(this.size));
+    }
+}

package/js/src/static_dependencies/ethers/coders/null.d.ts

@@ -0,0 +1,11 @@
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class NullCoder extends Coder {
+    constructor(localName: string);
+    defaultValue(): null;
+    encode(writer: Writer, value: any): number;
+    decode(reader: Reader): any;
+}

package/js/src/static_dependencies/ethers/coders/null.js

@@ -0,0 +1,29 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+import { Coder } from "./abstract-coder.js";
+const Empty = new Uint8Array([]);
+/**
+ *  @_ignore
+ */
+export class NullCoder extends Coder {
+    constructor(localName) {
+        super("null", "", localName, false);
+    }
+    defaultValue() {
+        return null;
+    }
+    encode(writer, value) {
+        if (value != null) {
+            this._throwError("not null", value);
+        }
+        return writer.writeBytes(Empty);
+    }
+    decode(reader) {
+        reader.readBytes(0);
+        return null;
+    }
+}

package/js/src/static_dependencies/ethers/coders/number.d.ts

@@ -0,0 +1,15 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { BigNumberish } from "../utils/index.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class NumberCoder extends Coder {
+    readonly size: number;
+    readonly signed: boolean;
+    constructor(size: number, signed: boolean, localName: string);
+    defaultValue(): number;
+    encode(writer: Writer, _value: BigNumberish | Typed): number;
+    decode(reader: Reader): any;
+}

package/js/src/static_dependencies/ethers/coders/number.js

@@ -0,0 +1,48 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+import { defineProperties, fromTwos, getBigInt, mask, toTwos } from "../utils/index.js";
+import { Typed } from "../typed.js";
+import { Coder, WordSize } from "./abstract-coder.js";
+const BN_0 = BigInt(0);
+const BN_1 = BigInt(1);
+const BN_MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+/**
+ *  @_ignore
+ */
+export class NumberCoder extends Coder {
+    constructor(size, signed, localName) {
+        const name = ((signed ? "int" : "uint") + (size * 8));
+        super(name, name, localName, false);
+        defineProperties(this, { size, signed }, { size: "number", signed: "boolean" });
+    }
+    defaultValue() {
+        return 0;
+    }
+    encode(writer, _value) {
+        let value = getBigInt(Typed.dereference(_value, this.type));
+        // Check bounds are safe for encoding
+        let maxUintValue = mask(BN_MAX_UINT256, WordSize * 8);
+        if (this.signed) {
+            let bounds = mask(maxUintValue, (this.size * 8) - 1);
+            if (value > bounds || value < -(bounds + BN_1)) {
+                this._throwError("value out-of-bounds", _value);
+            }
+            value = toTwos(value, 8 * WordSize);
+        }
+        else if (value < BN_0 || value > mask(maxUintValue, this.size * 8)) {
+            this._throwError("value out-of-bounds", _value);
+        }
+        return writer.writeValue(value);
+    }
+    decode(reader) {
+        let value = mask(reader.readValue(), this.size * 8);
+        if (this.signed) {
+            value = fromTwos(value, this.size * 8);
+        }
+        return value;
+    }
+}

package/js/src/static_dependencies/ethers/coders/string.d.ts

@@ -0,0 +1,12 @@
+import { Typed } from "../typed.js";
+import { DynamicBytesCoder } from "./bytes.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class StringCoder extends DynamicBytesCoder {
+    constructor(localName: string);
+    defaultValue(): string;
+    encode(writer: Writer, _value: string | Typed): number;
+    decode(reader: Reader): any;
+}

package/js/src/static_dependencies/ethers/coders/string.js

@@ -0,0 +1,26 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+import { toUtf8Bytes, toUtf8String } from "../utils/utf8.js";
+import { Typed } from "../typed.js";
+import { DynamicBytesCoder } from "./bytes.js";
+/**
+ *  @_ignore
+ */
+export class StringCoder extends DynamicBytesCoder {
+    constructor(localName) {
+        super("string", localName);
+    }
+    defaultValue() {
+        return "";
+    }
+    encode(writer, _value) {
+        return super.encode(writer, toUtf8Bytes(Typed.dereference(_value, "string")));
+    }
+    decode(reader) {
+        return toUtf8String(super.decode(reader));
+    }
+}

package/js/src/static_dependencies/ethers/coders/tuple.d.ts

@@ -0,0 +1,15 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class TupleCoder extends Coder {
+    readonly coders: ReadonlyArray<Coder>;
+    constructor(coders: Array<Coder>, localName: string);
+    defaultValue(): any;
+    encode(writer: Writer, _value: Array<any> | {
+        [name: string]: any;
+    } | Typed): number;
+    decode(reader: Reader): any;
+}

package/js/src/static_dependencies/ethers/coders/tuple.js

@@ -0,0 +1,67 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+import { defineProperties } from "../utils/properties.js";
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import { pack, unpack } from "./array.js";
+/**
+ *  @_ignore
+ */
+export class TupleCoder extends Coder {
+    constructor(coders, localName) {
+        let dynamic = false;
+        const types = [];
+        coders.forEach((coder) => {
+            if (coder.dynamic) {
+                dynamic = true;
+            }
+            types.push(coder.type);
+        });
+        const type = ("tuple(" + types.join(",") + ")");
+        super("tuple", type, localName, dynamic);
+        defineProperties(this, { coders: Object.freeze(coders.slice()) });
+    }
+    defaultValue() {
+        const values = [];
+        this.coders.forEach((coder) => {
+            values.push(coder.defaultValue());
+        });
+        // We only output named properties for uniquely named coders
+        const uniqueNames = this.coders.reduce((accum, coder) => {
+            const name = coder.localName;
+            if (name) {
+                if (!accum[name]) {
+                    accum[name] = 0;
+                }
+                accum[name]++;
+            }
+            return accum;
+        }, {});
+        // Add named values
+        this.coders.forEach((coder, index) => {
+            let name = coder.localName;
+            if (!name || uniqueNames[name] !== 1) {
+                return;
+            }
+            if (name === "length") {
+                name = "_length";
+            }
+            if (values[name] != null) {
+                return;
+            }
+            values[name] = values[index];
+        });
+        return Object.freeze(values);
+    }
+    encode(writer, _value) {
+        const value = Typed.dereference(_value, "tuple");
+        return pack(writer, this.coders, value);
+    }
+    decode(reader) {
+        return unpack(reader, this.coders);
+    }
+}