ccxt 4.3.70 → 4.3.72

package/dist/cjs/src/static_dependencies/starknet/utils/cairoDataTypes/uint512.js

@@ -0,0 +1,137 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var encode = require('../encode.js');
+var felt = require('./felt.js');
+var uint256 = require('./uint256.js');
+
+/* eslint-disable no-bitwise */
+const UINT_512_MAX = (1n << 512n) - 1n;
+const UINT_512_MIN = 0n;
+const UINT_128_MIN = 0n;
+class CairoUint512 {
+    constructor(...arr) {
+        if (typeof arr[0] === 'object' &&
+            arr.length === 1 &&
+            'limb0' in arr[0] &&
+            'limb1' in arr[0] &&
+            'limb2' in arr[0] &&
+            'limb3' in arr[0]) {
+            const props = CairoUint512.validateProps(arr[0].limb0, arr[0].limb1, arr[0].limb2, arr[0].limb3);
+            this.limb0 = props.limb0;
+            this.limb1 = props.limb1;
+            this.limb2 = props.limb2;
+            this.limb3 = props.limb3;
+        }
+        else if (arr.length === 1) {
+            const bigInt = CairoUint512.validate(arr[0]);
+            this.limb0 = bigInt & uint256.UINT_128_MAX;
+            this.limb1 = (bigInt & (uint256.UINT_128_MAX << 128n)) >> 128n;
+            this.limb2 = (bigInt & (uint256.UINT_128_MAX << 256n)) >> 256n;
+            this.limb3 = bigInt >> 384n;
+        }
+        else if (arr.length === 4) {
+            const props = CairoUint512.validateProps(arr[0], arr[1], arr[2], arr[3]);
+            this.limb0 = props.limb0;
+            this.limb1 = props.limb1;
+            this.limb2 = props.limb2;
+            this.limb3 = props.limb3;
+        }
+        else {
+            throw Error('Incorrect Uint512 constructor parameters');
+        }
+    }
+    /**
+     * Validate if BigNumberish can be represented as Uint512
+     */
+    static validate(bigNumberish) {
+        const bigInt = BigInt(bigNumberish);
+        if (bigInt < UINT_512_MIN)
+            throw Error('bigNumberish is smaller than UINT_512_MIN.');
+        if (bigInt > UINT_512_MAX)
+            throw Error('bigNumberish is bigger than UINT_512_MAX.');
+        return bigInt;
+    }
+    /**
+     * Validate if limbs can be represented as Uint512
+     */
+    static validateProps(limb0, limb1, limb2, limb3) {
+        const l0 = BigInt(limb0);
+        const l1 = BigInt(limb1);
+        const l2 = BigInt(limb2);
+        const l3 = BigInt(limb3);
+        [l0, l1, l2, l3].forEach((value, index) => {
+            if (value < UINT_128_MIN || value > uint256.UINT_128_MAX) {
+                throw Error(`limb${index} is not in the range of a u128 number`);
+            }
+        });
+        return { limb0: l0, limb1: l1, limb2: l2, limb3: l3 };
+    }
+    /**
+     * Check if BigNumberish can be represented as Uint512
+     */
+    static is(bigNumberish) {
+        try {
+            CairoUint512.validate(bigNumberish);
+        }
+        catch (error) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+        return abiType === CairoUint512.abiSelector;
+    }
+    /**
+     * Return bigint representation
+     */
+    toBigInt() {
+        return (this.limb3 << 384n) + (this.limb2 << 256n) + (this.limb1 << 128n) + this.limb0;
+    }
+    /**
+     * Return Uint512 structure with HexString props
+     * limbx: HexString
+     */
+    toUint512HexString() {
+        return {
+            limb0: encode.addHexPrefix(this.limb0.toString(16)),
+            limb1: encode.addHexPrefix(this.limb1.toString(16)),
+            limb2: encode.addHexPrefix(this.limb2.toString(16)),
+            limb3: encode.addHexPrefix(this.limb3.toString(16)),
+        };
+    }
+    /**
+     * Return Uint512 structure with DecimalString props
+     * limbx DecString
+     */
+    toUint512DecimalString() {
+        return {
+            limb0: this.limb0.toString(10),
+            limb1: this.limb1.toString(10),
+            limb2: this.limb2.toString(10),
+            limb3: this.limb3.toString(10),
+        };
+    }
+    /**
+     * Return api requests representation witch is felt array
+     */
+    toApiRequest() {
+        // lower limb first : https://github.com/starkware-libs/cairo/blob/07484c52791b76abcc18fd86265756904557d0d2/corelib/src/test/integer_test.cairo#L767
+        return [
+            felt.CairoFelt(this.limb0),
+            felt.CairoFelt(this.limb1),
+            felt.CairoFelt(this.limb2),
+            felt.CairoFelt(this.limb3),
+        ];
+    }
+}
+CairoUint512.abiSelector = 'core::integer::u512';
+
+exports.CairoUint512 = CairoUint512;
+exports.UINT_128_MIN = UINT_128_MIN;
+exports.UINT_512_MAX = UINT_512_MAX;
+exports.UINT_512_MIN = UINT_512_MIN;

package/dist/cjs/src/static_dependencies/starknet/utils/calldata/byteArray.js

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var num = require('../num.js');
+var shortString = require('../shortString.js');
+
+/**
+ * convert a Cairo ByteArray to a JS string
+ * @param myByteArray Cairo representation of a LongString
+ * @returns a JS string
+ * @example
+ * ```typescript
+ * const myByteArray = {
+ *    data: [],
+ *    pending_word: '0x414243444546474849',
+ *    pending_word_len: 9
+ * }
+ * const result: String = stringFromByteArray(myByteArray); // ABCDEFGHI
+ * ```
+ */
+function stringFromByteArray(myByteArray) {
+    const pending_word = BigInt(myByteArray.pending_word) === 0n
+        ? ''
+        : shortString.decodeShortString(num.toHex(myByteArray.pending_word));
+    return (myByteArray.data.reduce((cumuledString, encodedString) => {
+        const add = BigInt(encodedString) === 0n ? '' : shortString.decodeShortString(num.toHex(encodedString));
+        return cumuledString + add;
+    }, '') + pending_word);
+}
+/**
+ * convert a JS string to a Cairo ByteArray
+ * @param targetString a JS string
+ * @returns Cairo representation of a LongString
+ * @example
+ * ```typescript
+ * const myByteArray: ByteArray = byteArrayFromString("ABCDEFGHI");
+ * ```
+ * Result is :
+ * {
+ *    data: [],
+ *    pending_word: '0x414243444546474849',
+ *    pending_word_len: 9
+ * }
+ */
+function byteArrayFromString(targetString) {
+    const shortStrings = shortString.splitLongString(targetString);
+    const remainder = shortStrings[shortStrings.length - 1];
+    const shortStringsEncoded = shortStrings.map(shortString.encodeShortString);
+    const [pendingWord, pendingWordLength] = remainder === undefined || remainder.length === 31
+        ? ['0x00', 0]
+        : [shortStringsEncoded.pop(), remainder.length];
+    return {
+        data: shortStringsEncoded.length === 0 ? [] : shortStringsEncoded,
+        pending_word: pendingWord,
+        pending_word_len: pendingWordLength,
+    };
+}
+
+exports.byteArrayFromString = byteArrayFromString;
+exports.stringFromByteArray = stringFromByteArray;

package/dist/cjs/src/static_dependencies/starknet/utils/calldata/cairo.js

@@ -0,0 +1,218 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var calldata = require('../../types/calldata.js');
+require('../../types/lib/index.js');
+var felt$1 = require('../cairoDataTypes/felt.js');
+var uint256$1 = require('../cairoDataTypes/uint256.js');
+require('../cairoDataTypes/uint512.js');
+
+// Intended for internal usage, maybe should be exported somewhere else and not exported to utils
+/**
+ * Checks if the given name ends with "_len".
+ *
+ * @param {string} name - The name to be checked.
+ * @returns - True if the name ends with "_len", false otherwise.
+ */
+const isLen = (name) => /_len$/.test(name);
+/**
+ * Checks if a given type is felt.
+ *
+ * @param {string} type - The type to check.
+ * @returns - True if the type is felt, false otherwise.
+ */
+const isTypeFelt = (type) => type === 'felt' || type === 'core::felt252';
+/**
+ * Checks if the given type is an array type.
+ *
+ * @param {string} type - The type to check.
+ * @returns - `true` if the type is an array type, `false` otherwise.
+ */
+const isTypeArray = (type) => /\*/.test(type) ||
+    type.startsWith('core::array::Array::') ||
+    type.startsWith('core::array::Span::');
+/**
+ * Checks if the given type is a tuple type.
+ *
+ * @param {string} type - The type to be checked.
+ * @returns - `true` if the type is a tuple type, otherwise `false`.
+ */
+const isTypeTuple = (type) => /^\(.*\)$/i.test(type);
+/**
+ * Checks whether a given type is a named tuple.
+ *
+ * @param {string} type - The type to be checked.
+ * @returns - True if the type is a named tuple, false otherwise.
+ */
+const isTypeNamedTuple = (type) => /\(.*\)/i.test(type) && type.includes(':');
+/**
+ * Checks if a given type is a struct.
+ *
+ * @param {string} type - The type to check for existence.
+ * @param {AbiStructs} structs - The collection of structs to search in.
+ * @returns - True if the type exists in the structs, false otherwise.
+ */
+const isTypeStruct = (type, structs) => type in structs;
+/**
+ * Checks if a given type is an enum.
+ *
+ * @param {string} type - The type to check.
+ * @param {AbiEnums} enums - The enumeration to search in.
+ * @returns - True if the type exists in the enumeration, otherwise false.
+ */
+const isTypeEnum = (type, enums) => type in enums;
+/**
+ * Determines if the given type is an Option type.
+ *
+ * @param {string} type - The type to check.
+ * @returns - True if the type is an Option type, false otherwise.
+ */
+const isTypeOption = (type) => type.startsWith('core::option::Option::');
+/**
+ * Checks whether a given type starts with 'core::result::Result::'.
+ *
+ * @param {string} type - The type to check.
+ * @returns - True if the type starts with 'core::result::Result::', false otherwise.
+ */
+const isTypeResult = (type) => type.startsWith('core::result::Result::');
+/**
+ * Checks if the given value is a valid Uint type.
+ *
+ * @param {string} type - The value to check.
+ * @returns - Returns true if the value is a valid Uint type, otherwise false.
+ */
+const isTypeUint = (type) => Object.values(calldata.Uint).includes(type);
+/**
+ * Checks if the given type is a literal type.
+ *
+ * @param {string} type - The type to check.
+ * @returns - True if the type is a literal type, false otherwise.
+ */
+const isTypeLiteral = (type) => Object.values(calldata.Literal).includes(type);
+/**
+ * Checks if the given type is a boolean type.
+ *
+ * @param {string} type - The type to be checked.
+ * @returns - Returns true if the type is a boolean type, otherwise false.
+ */
+const isTypeBool = (type) => type === 'core::bool';
+/**
+ * Determines if the given type is an Ethereum address type.
+ *
+ * @param {string} type - The type to check.
+ * @returns - Returns true if the given type is 'core::starknet::eth_address::EthAddress', otherwise false.
+ */
+const isTypeEthAddress = (type) => type === 'core::starknet::eth_address::EthAddress';
+/**
+ * Checks if the given type is 'core::bytes_31::bytes31'.
+ *
+ * @param {string} type - The type to check.
+ * @returns - True if the type is 'core::bytes_31::bytes31', false otherwise.
+ */
+const isTypeBytes31 = (type) => type === 'core::bytes_31::bytes31';
+/**
+ * Checks if the given type is equal to the 'core::byte_array::ByteArray'.
+ *
+ * @param {string} type - The type to check.
+ * @returns - True if the given type is equal to 'core::byte_array::ByteArray', false otherwise.
+ */
+const isTypeByteArray = (type) => type === 'core::byte_array::byteArray.js';
+const isTypeSecp256k1Point = (type) => type === 'core::starknet::secp256k1::Secp256k1Point';
+const isCairo1Type = (type) => type.includes('::');
+/**
+ * Retrieves the array type from the given type string.
+ *
+ * @param {string} type - The type string.
+ * @returns - The array type.
+ */
+const getArrayType = (type) => {
+    if (isCairo1Type(type)) {
+        return type.substring(type.indexOf('<') + 1, type.lastIndexOf('>'));
+    }
+    return type.replace('*', '');
+};
+/**
+ * Test if an ABI comes from a Cairo 1 contract
+ * @param abi representing the interface of a Cairo contract
+ * @returns TRUE if it is an ABI from a Cairo1 contract
+ * @example
+ * ```typescript
+ * const isCairo1: boolean = isCairo1Abi(myAbi: Abi);
+ * ```
+ */
+function isCairo1Abi(abi) {
+    const { cairo } = getAbiContractVersion(abi);
+    if (cairo === undefined) {
+        throw Error('Unable to determine Cairo version');
+    }
+    return cairo === '1';
+}
+/**
+ * Return ContractVersion (Abi version) based on Abi
+ * or undefined for unknown version
+ * @param abi
+ * @returns string
+ */
+function getAbiContractVersion(abi) {
+    // determine by interface for "Cairo 1.2"
+    if (abi.find((it) => it.type === 'interface')) {
+        return { cairo: '1', compiler: '2' };
+    }
+    // determine by function io types "Cairo 1.1" or "Cairo 0.0"
+    // find first function with inputs or outputs
+    const testFunction = abi.find((it) => it.type === 'function' && (it.inputs.length || it.outputs.length));
+    if (!testFunction) {
+        return { cairo: undefined, compiler: undefined };
+    }
+    const io = testFunction.inputs.length ? testFunction.inputs : testFunction.outputs;
+    if (isCairo1Type(io[0].type)) {
+        return { cairo: '1', compiler: '1' };
+    }
+    return { cairo: '0', compiler: '0' };
+}
+/**
+ * named tuple cairo type is described as js object {}
+ * struct cairo type are described as js object {}
+ * array cairo type are described as js array []
+ */
+/**
+ * Create Uint256 Cairo type (helper for common struct type)
+ * @example
+ * ```typescript
+ * uint256('892349863487563453485768723498');
+ * ```
+ */
+const uint256 = (it) => {
+    return new uint256$1.CairoUint256(it).toUint256DecimalString();
+};
+/**
+ * Create felt Cairo type (cairo type helper)
+ * @returns format: felt-string
+ */
+function felt(it) {
+    return felt$1.CairoFelt(it);
+}
+
+exports.felt = felt;
+exports.getAbiContractVersion = getAbiContractVersion;
+exports.getArrayType = getArrayType;
+exports.isCairo1Abi = isCairo1Abi;
+exports.isCairo1Type = isCairo1Type;
+exports.isLen = isLen;
+exports.isTypeArray = isTypeArray;
+exports.isTypeBool = isTypeBool;
+exports.isTypeByteArray = isTypeByteArray;
+exports.isTypeBytes31 = isTypeBytes31;
+exports.isTypeEnum = isTypeEnum;
+exports.isTypeEthAddress = isTypeEthAddress;
+exports.isTypeFelt = isTypeFelt;
+exports.isTypeLiteral = isTypeLiteral;
+exports.isTypeNamedTuple = isTypeNamedTuple;
+exports.isTypeOption = isTypeOption;
+exports.isTypeResult = isTypeResult;
+exports.isTypeSecp256k1Point = isTypeSecp256k1Point;
+exports.isTypeStruct = isTypeStruct;
+exports.isTypeTuple = isTypeTuple;
+exports.isTypeUint = isTypeUint;
+exports.uint256 = uint256;

package/dist/cjs/src/static_dependencies/starknet/utils/calldata/enum/CairoCustomEnum.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Class to handle Cairo custom Enum
+ * @param enumContent object containing the variants and its content. Example :
+ *  {Success: 234, Warning: undefined, Error: undefined}.
+ *  Only one variant with a value, object, array.
+ * @returns an instance representing a Cairo custom Enum.
+ * @example
+ * ```typescript
+ * const myCairoEnum = new CairoCustomEnum( {Success: undefined, Warning: "0x7f32ea", Error: undefined})
+ * ```
+ */
+class CairoCustomEnum {
+    /**
+     * @param enumContent an object with the variants as keys and the content as value. Only one content shall be defined.
+     */
+    constructor(enumContent) {
+        const variantsList = Object.values(enumContent);
+        if (variantsList.length === 0) {
+            throw new Error('This Enum must have at least 1 variant');
+        }
+        const nbActiveVariants = variantsList.filter((content) => typeof content !== 'undefined').length;
+        if (nbActiveVariants !== 1) {
+            throw new Error('This Enum must have exactly one active variant');
+        }
+        this.variant = enumContent;
+    }
+    /**
+     *
+     * @returns the content of the valid variant of a Cairo custom Enum.
+     */
+    unwrap() {
+        const variants = Object.entries(this.variant);
+        const activeVariant = variants.find((item) => typeof item[1] !== 'undefined');
+        if (typeof activeVariant === 'undefined') {
+            return undefined;
+        }
+        return activeVariant[1];
+    }
+    /**
+     *
+     * @returns the name of the valid variant of a Cairo custom Enum.
+     */
+    activeVariant() {
+        const variants = Object.entries(this.variant);
+        const activeVariant = variants.find((item) => typeof item[1] !== 'undefined');
+        if (typeof activeVariant === 'undefined') {
+            return '';
+        }
+        return activeVariant[0];
+    }
+}
+
+exports.CairoCustomEnum = CairoCustomEnum;

package/dist/cjs/src/static_dependencies/starknet/utils/calldata/enum/CairoOption.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+exports.CairoOptionVariant = void 0;
+(function (CairoOptionVariant) {
+    CairoOptionVariant[CairoOptionVariant["Some"] = 0] = "Some";
+    CairoOptionVariant[CairoOptionVariant["None"] = 1] = "None";
+})(exports.CairoOptionVariant || (exports.CairoOptionVariant = {}));
+/**
+ * Class to handle Cairo Option
+ * @param variant CairoOptionVariant.Some or CairoOptionVariant.None
+ * @param someContent value of type T.
+ * @returns an instance representing a Cairo Option.
+ * @example
+ * ```typescript
+ * const myOption = new CairoOption<BigNumberish>(CairoOptionVariant.Some, "0x54dda8");
+ * ```
+ */
+class CairoOption {
+    constructor(variant, someContent) {
+        if (!(variant in exports.CairoOptionVariant)) {
+            throw new Error('Wrong variant : should be CairoOptionVariant.Some or .None.');
+        }
+        if (variant === exports.CairoOptionVariant.Some) {
+            if (typeof someContent === 'undefined') {
+                throw new Error('The creation of a Cairo Option with "Some" variant needs a content as input.');
+            }
+            this.Some = someContent;
+            this.None = undefined;
+        }
+        else {
+            this.Some = undefined;
+            this.None = true;
+        }
+    }
+    /**
+     *
+     * @returns the content of the valid variant of a Cairo custom Enum.
+     *  If None, returns 'undefined'.
+     */
+    unwrap() {
+        if (this.None) {
+            return undefined;
+        }
+        return this.Some;
+    }
+    /**
+     *
+     * @returns true if the valid variant is 'isSome'.
+     */
+    isSome() {
+        return !(typeof this.Some === 'undefined');
+    }
+    /**
+     *
+     * @returns true if the valid variant is 'isNone'.
+     */
+    isNone() {
+        return this.None === true;
+    }
+}
+
+exports.CairoOption = CairoOption;

package/dist/cjs/src/static_dependencies/starknet/utils/calldata/enum/CairoResult.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+exports.CairoResultVariant = void 0;
+(function (CairoResultVariant) {
+    CairoResultVariant[CairoResultVariant["Ok"] = 0] = "Ok";
+    CairoResultVariant[CairoResultVariant["Err"] = 1] = "Err";
+})(exports.CairoResultVariant || (exports.CairoResultVariant = {}));
+/**
+ * Class to handle Cairo Result
+ * @param variant CairoResultVariant.Ok or CairoResultVariant.Err
+ * @param resultContent value of type T or U.
+ * @returns an instance representing a Cairo Result.
+ * @example
+ * ```typescript
+ * const myOption = new CairoResult<BigNumberish, CustomError>(CairoResultVariant.Ok, "0x54dda8");
+ * ```
+ */
+class CairoResult {
+    constructor(variant, resultContent) {
+        if (!(variant in exports.CairoResultVariant)) {
+            throw new Error('Wrong variant : should be CairoResultVariant.Ok or .Err.');
+        }
+        if (variant === exports.CairoResultVariant.Ok) {
+            this.Ok = resultContent;
+            this.Err = undefined;
+        }
+        else {
+            this.Ok = undefined;
+            this.Err = resultContent;
+        }
+    }
+    /**
+     *
+     * @returns the content of the valid variant of a Cairo Result.
+     */
+    unwrap() {
+        if (typeof this.Ok !== 'undefined') {
+            return this.Ok;
+        }
+        if (typeof this.Err !== 'undefined') {
+            return this.Err;
+        }
+        throw new Error('Both Result.Ok and .Err are undefined. Not authorized.');
+    }
+    /**
+     *
+     * @returns true if the valid variant is 'Ok'.
+     */
+    isOk() {
+        return !(typeof this.Ok === 'undefined');
+    }
+    /**
+     *
+     * @returns true if the valid variant is 'isErr'.
+     */
+    isErr() {
+        return !(typeof this.Err === 'undefined');
+    }
+}
+
+exports.CairoResult = CairoResult;

package/dist/cjs/src/static_dependencies/starknet/utils/calldata/formatter.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var num = require('../num.js');
+var shortString = require('../shortString.js');
+
+const guard = {
+    isBN: (data, type, key) => {
+        if (!num.isBigInt(data[key]))
+            throw new Error(`Data and formatter mismatch on ${key}:${type[key]}, expected response data ${key}:${data[key]} to be BN instead it is ${typeof data[key]}`);
+    },
+    unknown: (data, type, key) => {
+        throw new Error(`Unhandled formatter type on ${key}:${type[key]} for data ${key}:${data[key]}`);
+    },
+};
+/**
+ * Formats the given data based on the provided type definition.
+ *
+ * @param {any} data - The data to be formatted.
+ * @param {any} type - The type definition for the data.
+ * @param {any} [sameType] - The same type definition to be used (optional).
+ * @returns - The formatted data.
+ */
+function formatter(data, type, sameType) {
+    // match data element with type element
+    return Object.entries(data).reduce((acc, [key, value]) => {
+        const elType = sameType ?? type[key];
+        if (!(key in type) && !sameType) {
+            // no type definition for element return original element
+            acc[key] = value;
+            return acc;
+        }
+        if (elType === 'string') {
+            if (Array.isArray(data[key])) {
+                // long string (felt*)
+                const arrayStr = formatter(data[key], data[key].map((_) => elType));
+                acc[key] = Object.values(arrayStr).join('');
+                return acc;
+            }
+            guard.isBN(data, type, key);
+            acc[key] = shortString.decodeShortString(value);
+            return acc;
+        }
+        if (elType === 'number') {
+            guard.isBN(data, type, key);
+            acc[key] = Number(value);
+            return acc;
+        }
+        if (typeof elType === 'function') {
+            acc[key] = elType(value);
+            return acc;
+        }
+        if (Array.isArray(elType)) {
+            const arrayObj = formatter(data[key], elType, elType[0]);
+            acc[key] = Object.values(arrayObj);
+            return acc;
+        }
+        if (typeof elType === 'object') {
+            acc[key] = formatter(data[key], elType);
+            return acc;
+        }
+        guard.unknown(data, type, key);
+        return acc;
+    }, {});
+}
+
+module.exports = formatter;