ccxt 4.2.60 → 4.2.61

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

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../utils/base58.js');
+var data = require('../utils/data.js');
+require('../utils/errors.js');
+require('../utils/events.js');
+require('../utils/fixednumber.js');
+require('../utils/maths.js');
+require('../utils/utf8.js');
+require('../../../base/functions/platform.js');
+require('../../../base/functions/encode.js');
+require('../../../base/functions/crypto.js');
+require('../../noble-hashes/sha3.js');
+require('../../noble-hashes/sha256.js');
+var abstractCoder = require('./abstract-coder.js');
+
+/**
+ *  @_ignore
+ */
+class DynamicBytesCoder extends abstractCoder.Coder {
+    constructor(type, localName) {
+        super(type, type, localName, true);
+    }
+    defaultValue() {
+        return "0x";
+    }
+    encode(writer, value) {
+        value = data.getBytesCopy(value);
+        let length = writer.writeValue(value.length);
+        length += writer.writeBytes(value);
+        return length;
+    }
+    decode(reader) {
+        return reader.readBytes(reader.readIndex(), true);
+    }
+}
+/**
+ *  @_ignore
+ */
+class BytesCoder extends DynamicBytesCoder {
+    constructor(localName) {
+        super("bytes", localName);
+    }
+    decode(reader) {
+        return data.hexlify(super.decode(reader));
+    }
+}
+
+exports.BytesCoder = BytesCoder;
+exports.DynamicBytesCoder = DynamicBytesCoder;

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

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../utils/base58.js');
+var data = require('../utils/data.js');
+require('../utils/errors.js');
+require('../utils/events.js');
+require('../utils/fixednumber.js');
+require('../utils/maths.js');
+var properties = require('../utils/properties.js');
+require('../utils/utf8.js');
+require('../../../base/functions/platform.js');
+require('../../../base/functions/encode.js');
+require('../../../base/functions/crypto.js');
+require('../../noble-hashes/sha3.js');
+require('../../noble-hashes/sha256.js');
+var typed = require('../typed.js');
+var abstractCoder = require('./abstract-coder.js');
+
+/**
+ *  @_ignore
+ */
+class FixedBytesCoder extends abstractCoder.Coder {
+    constructor(size, localName) {
+        let name = "bytes" + String(size);
+        super(name, name, localName, false);
+        properties.defineProperties(this, { size }, { size: "number" });
+    }
+    defaultValue() {
+        return ("0x0000000000000000000000000000000000000000000000000000000000000000").substring(0, 2 + this.size * 2);
+    }
+    encode(writer, _value) {
+        let data$1 = data.getBytesCopy(typed.Typed.dereference(_value, this.type));
+        if (data$1.length !== this.size) {
+            this._throwError("incorrect data length", _value);
+        }
+        return writer.writeBytes(data$1);
+    }
+    decode(reader) {
+        return data.hexlify(reader.readBytes(this.size));
+    }
+}
+
+exports.FixedBytesCoder = FixedBytesCoder;

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

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var abstractCoder = require('./abstract-coder.js');
+
+const Empty = new Uint8Array([]);
+/**
+ *  @_ignore
+ */
+class NullCoder extends abstractCoder.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;
+    }
+}
+
+exports.NullCoder = NullCoder;

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

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../utils/base58.js');
+require('../utils/errors.js');
+require('../utils/events.js');
+require('../utils/fixednumber.js');
+var maths = require('../utils/maths.js');
+var properties = require('../utils/properties.js');
+require('../utils/utf8.js');
+require('../../../base/functions/platform.js');
+require('../../../base/functions/encode.js');
+require('../../../base/functions/crypto.js');
+require('../../noble-hashes/sha3.js');
+require('../../noble-hashes/sha256.js');
+var typed = require('../typed.js');
+var abstractCoder = require('./abstract-coder.js');
+
+const BN_0 = BigInt(0);
+const BN_1 = BigInt(1);
+const BN_MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+/**
+ *  @_ignore
+ */
+class NumberCoder extends abstractCoder.Coder {
+    constructor(size, signed, localName) {
+        const name = ((signed ? "int" : "uint") + (size * 8));
+        super(name, name, localName, false);
+        properties.defineProperties(this, { size, signed }, { size: "number", signed: "boolean" });
+    }
+    defaultValue() {
+        return 0;
+    }
+    encode(writer, _value) {
+        let value = maths.getBigInt(typed.Typed.dereference(_value, this.type));
+        // Check bounds are safe for encoding
+        let maxUintValue = maths.mask(BN_MAX_UINT256, abstractCoder.WordSize * 8);
+        if (this.signed) {
+            let bounds = maths.mask(maxUintValue, (this.size * 8) - 1);
+            if (value > bounds || value < -(bounds + BN_1)) {
+                this._throwError("value out-of-bounds", _value);
+            }
+            value = maths.toTwos(value, 8 * abstractCoder.WordSize);
+        }
+        else if (value < BN_0 || value > maths.mask(maxUintValue, this.size * 8)) {
+            this._throwError("value out-of-bounds", _value);
+        }
+        return writer.writeValue(value);
+    }
+    decode(reader) {
+        let value = maths.mask(reader.readValue(), this.size * 8);
+        if (this.signed) {
+            value = maths.fromTwos(value, this.size * 8);
+        }
+        return value;
+    }
+}
+
+exports.NumberCoder = NumberCoder;

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

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utf8 = require('../utils/utf8.js');
+var typed = require('../typed.js');
+var bytes = require('./bytes.js');
+
+/**
+ *  @_ignore
+ */
+class StringCoder extends bytes.DynamicBytesCoder {
+    constructor(localName) {
+        super("string", localName);
+    }
+    defaultValue() {
+        return "";
+    }
+    encode(writer, _value) {
+        return super.encode(writer, utf8.toUtf8Bytes(typed.Typed.dereference(_value, "string")));
+    }
+    decode(reader) {
+        return utf8.toUtf8String(super.decode(reader));
+    }
+}
+
+exports.StringCoder = StringCoder;

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

@@ -0,0 +1,68 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var properties = require('../utils/properties.js');
+var typed = require('../typed.js');
+var abstractCoder = require('./abstract-coder.js');
+var array = require('./array.js');
+
+/**
+ *  @_ignore
+ */
+class TupleCoder extends abstractCoder.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);
+        properties.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.Typed.dereference(_value, "tuple");
+        return array.pack(writer, this.coders, value);
+    }
+    decode(reader) {
+        return array.unpack(reader, this.coders);
+    }
+}
+
+exports.TupleCoder = TupleCoder;