ccxt 4.3.70 → 4.3.72

package/js/src/static_dependencies/starknet/utils/calldata/parser/parser-2.0.0.d.ts

@@ -0,0 +1,23 @@
+import { Abi, FunctionAbi } from '../../../types/index.js';
+import { AbiParserInterface } from './interface.js';
+export declare class AbiParser2 implements AbiParserInterface {
+    abi: Abi;
+    constructor(abi: Abi);
+    /**
+     * abi method inputs length
+     * @param abiMethod FunctionAbi
+     * @returns number
+     */
+    methodInputsLength(abiMethod: FunctionAbi): number;
+    /**
+     * get method definition from abi
+     * @param name string
+     * @returns FunctionAbi | undefined
+     */
+    getMethod(name: string): FunctionAbi | undefined;
+    /**
+     * Get Abi in legacy format
+     * @returns Abi
+     */
+    getLegacyFormat(): Abi;
+}

package/js/src/static_dependencies/starknet/utils/calldata/parser/parser-2.0.0.js

@@ -0,0 +1,40 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+export class AbiParser2 {
+    constructor(abi) {
+        this.abi = abi;
+    }
+    /**
+     * abi method inputs length
+     * @param abiMethod FunctionAbi
+     * @returns number
+     */
+    methodInputsLength(abiMethod) {
+        return abiMethod.inputs.length;
+    }
+    /**
+     * get method definition from abi
+     * @param name string
+     * @returns FunctionAbi | undefined
+     */
+    getMethod(name) {
+        const intf = this.abi.find((it) => it.type === 'interface');
+        return intf.items.find((it) => it.name === name);
+    }
+    /**
+     * Get Abi in legacy format
+     * @returns Abi
+     */
+    getLegacyFormat() {
+        return this.abi.flatMap((e) => {
+            if (e.type === 'interface') {
+                return e.items;
+            }
+            return e;
+        });
+    }
+}

package/js/src/static_dependencies/starknet/utils/calldata/propertyOrder.d.ts

@@ -0,0 +1,2 @@
+import { AbiEntry, AbiEnums, AbiStructs, RawArgsObject } from '../../types/index.js';
+export default function orderPropsByAbi(unorderedObject: RawArgsObject, abiOfObject: AbiEntry[], structs: AbiStructs, enums: AbiEnums): object;

package/js/src/static_dependencies/starknet/utils/calldata/propertyOrder.js

@@ -0,0 +1,155 @@
+// ----------------------------------------------------------------------------
+
+// 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 { CairoUint256 } from '../cairoDataTypes/uint256.js';
+import { CairoUint512 } from '../cairoDataTypes/uint512.js';
+import { getArrayType, isCairo1Type, isLen, isTypeArray, isTypeByteArray, isTypeEnum, isTypeEthAddress, isTypeOption, isTypeResult, isTypeSecp256k1Point, isTypeStruct, isTypeTuple, } from './cairo.js';
+import { CairoCustomEnum, CairoOption, CairoOptionVariant, CairoResult, CairoResultVariant, } from './enum/index.js';
+import extractTupleMemberTypes from './tuple.js';
+import { isString } from '../shortString.js';
+function errorU256(key) {
+    return Error(`Your object includes the property : ${key}, containing an Uint256 object without the 'low' and 'high' keys.`);
+}
+function errorU512(key) {
+    return Error(`Your object includes the property : ${key}, containing an Uint512 object without the 'limb0' to 'limb3' keys.`);
+}
+export default function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
+    const orderInput = (unorderedItem, abiType) => {
+        if (isTypeArray(abiType)) {
+            return orderArray(unorderedItem, abiType);
+        }
+        if (isTypeEnum(abiType, enums)) {
+            const abiObj = enums[abiType];
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            return orderEnum(unorderedItem, abiObj);
+        }
+        if (isTypeTuple(abiType)) {
+            return orderTuple(unorderedItem, abiType);
+        }
+        if (isTypeEthAddress(abiType)) {
+            return unorderedItem;
+        }
+        if (isTypeByteArray(abiType)) {
+            return unorderedItem;
+        }
+        if (isTypeSecp256k1Point(abiType)) {
+            return unorderedItem;
+        }
+        if (CairoUint256.isAbiType(abiType)) {
+            const u256 = unorderedItem;
+            if (typeof u256 !== 'object') {
+                // BigNumberish --> just copy
+                return u256;
+            }
+            if (!('low' in u256 && 'high' in u256)) {
+                throw errorU256(abiType);
+            }
+            return { low: u256.low, high: u256.high };
+        }
+        if (CairoUint512.isAbiType(abiType)) {
+            const u512 = unorderedItem;
+            if (typeof u512 !== 'object') {
+                // BigNumberish --> just copy
+                return u512;
+            }
+            if (!['limb0', 'limb1', 'limb2', 'limb3'].every((key) => key in u512)) {
+                throw errorU512(abiType);
+            }
+            return { limb0: u512.limb0, limb1: u512.limb1, limb2: u512.limb2, limb3: u512.limb3 };
+        }
+        if (isTypeStruct(abiType, structs)) {
+            const abiOfStruct = structs[abiType].members;
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            return orderStruct(unorderedItem, abiOfStruct);
+        }
+        // literals
+        return unorderedItem;
+    };
+    const orderStruct = (unorderedObject2, abiObject) => {
+        const orderedObject2 = abiObject.reduce((orderedObject, abiParam) => {
+            const setProperty = (value) => Object.defineProperty(orderedObject, abiParam.name, {
+                enumerable: true,
+                value: value ?? unorderedObject2[abiParam.name],
+            });
+            if (unorderedObject2[abiParam.name] === 'undefined') {
+                if (isCairo1Type(abiParam.type) || !isLen(abiParam.name)) {
+                    throw Error(`Your object needs a property with key : ${abiParam.name} .`);
+                }
+            }
+            setProperty(orderInput(unorderedObject2[abiParam.name], abiParam.type));
+            return orderedObject;
+        }, {});
+        return orderedObject2;
+    };
+    function orderArray(myArray, abiParam) {
+        const typeInArray = getArrayType(abiParam);
+        if (isString(myArray)) {
+            return myArray; // longstring
+        }
+        return myArray.map((myElem) => orderInput(myElem, typeInArray));
+    }
+    function orderTuple(unorderedObject2, abiParam) {
+        const typeList = extractTupleMemberTypes(abiParam);
+        const orderedObject2 = typeList.reduce((orderedObject, abiTypeCairoX, index) => {
+            const myObjKeys = Object.keys(unorderedObject2);
+            const setProperty = (value) => Object.defineProperty(orderedObject, index.toString(), {
+                enumerable: true,
+                value: value ?? unorderedObject2[myObjKeys[index]],
+            });
+            const abiType = abiTypeCairoX?.type ? abiTypeCairoX.type : abiTypeCairoX; // Named tuple, or tuple
+            setProperty(orderInput(unorderedObject2[myObjKeys[index]], abiType));
+            return orderedObject;
+        }, {});
+        return orderedObject2;
+    }
+    const orderEnum = (unorderedObject2, abiObject) => {
+        if (isTypeResult(abiObject.name)) {
+            const unorderedResult = unorderedObject2;
+            const resultOkType = abiObject.name.substring(abiObject.name.indexOf('<') + 1, abiObject.name.lastIndexOf(','));
+            const resultErrType = abiObject.name.substring(abiObject.name.indexOf(',') + 1, abiObject.name.lastIndexOf('>'));
+            if (unorderedResult.isOk()) {
+                return new CairoResult(CairoResultVariant.Ok, orderInput(unorderedObject2.unwrap(), resultOkType));
+            }
+            return new CairoResult(CairoResultVariant.Err, orderInput(unorderedObject2.unwrap(), resultErrType));
+        }
+        if (isTypeOption(abiObject.name)) {
+            const unorderedOption = unorderedObject2;
+            const resultSomeType = abiObject.name.substring(abiObject.name.indexOf('<') + 1, abiObject.name.lastIndexOf('>'));
+            if (unorderedOption.isSome()) {
+                return new CairoOption(CairoOptionVariant.Some, orderInput(unorderedOption.unwrap(), resultSomeType));
+            }
+            // none(())
+            return new CairoOption(CairoOptionVariant.None, {});
+        }
+        // custom Enum
+        const unorderedCustomEnum = unorderedObject2;
+        const variants = Object.entries(unorderedCustomEnum.variant);
+        const newEntries = variants.map((variant) => {
+            if (typeof variant[1] === 'undefined') {
+                return variant;
+            }
+            const variantType = abiObject.type.substring(abiObject.type.lastIndexOf('<') + 1, abiObject.type.lastIndexOf('>'));
+            if (variantType === '()') {
+                return variant;
+            }
+            return [variant[0], orderInput(unorderedCustomEnum.unwrap(), variantType)];
+        });
+        return new CairoCustomEnum(Object.fromEntries(newEntries));
+    };
+    // Order Call Parameters
+    const finalOrderedObject = abiOfObject.reduce((orderedObject, abiParam) => {
+        const setProperty = (value) => Object.defineProperty(orderedObject, abiParam.name, {
+            enumerable: true,
+            value,
+        });
+        if (isLen(abiParam.name) && !isCairo1Type(abiParam.type)) {
+            return orderedObject;
+        }
+        setProperty(orderInput(unorderedObject[abiParam.name], abiParam.type));
+        return orderedObject;
+    }, {});
+    return finalOrderedObject;
+}

package/js/src/static_dependencies/starknet/utils/calldata/requestParser.d.ts

@@ -0,0 +1,11 @@
+import { AbiEntry, AbiEnums, AbiStructs } from '../../types/index.js';
+/**
+ * Parse one field of the calldata by using input field from the abi for that method
+ *
+ * @param argsIterator - Iterator for value of the field
+ * @param input  - input(field) information from the abi that will be used to parse the data
+ * @param structs - structs from abi
+ * @param enums - enums from abi
+ * @return {string | string[]} - parsed arguments in format that contract is expecting
+ */
+export declare function parseCalldataField(argsIterator: Iterator<any>, input: AbiEntry, structs: AbiStructs, enums: AbiEnums): string | string[];

package/js/src/static_dependencies/starknet/utils/calldata/requestParser.js

@@ -0,0 +1,248 @@
+// ----------------------------------------------------------------------------
+
+// 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 { CairoUint256 } from '../cairoDataTypes/uint256.js';
+import { CairoUint512 } from '../cairoDataTypes/uint512.js';
+import { addHexPrefix, removeHexPrefix } from '../encode.js';
+import { toHex } from '../num.js';
+import { encodeShortString, isString, isText, splitLongString } from '../shortString.js';
+import { byteArrayFromString } from './byteArray.js';
+import { felt, getArrayType, isTypeArray, isTypeBytes31, isTypeEnum, isTypeOption, isTypeResult, isTypeSecp256k1Point, isTypeStruct, isTypeTuple, uint256, } from './cairo.js';
+import { CairoOptionVariant, CairoResultVariant, } from './enum/index.js';
+import extractTupleMemberTypes from './tuple.js';
+/**
+ * parse base types
+ * @param type type from abi
+ * @param val value provided
+ * @returns string | string[]
+ */
+function parseBaseTypes(type, val) {
+    switch (true) {
+        case CairoUint256.isAbiType(type):
+            return new CairoUint256(val).toApiRequest();
+        case CairoUint512.isAbiType(type):
+            return new CairoUint512(val).toApiRequest();
+        case isTypeBytes31(type):
+            return encodeShortString(val.toString());
+        case isTypeSecp256k1Point(type): {
+            const pubKeyETH = removeHexPrefix(toHex(val)).padStart(128, '0');
+            const pubKeyETHy = uint256(addHexPrefix(pubKeyETH.slice(-64)));
+            const pubKeyETHx = uint256(addHexPrefix(pubKeyETH.slice(0, -64)));
+            return [
+                felt(pubKeyETHx.low),
+                felt(pubKeyETHx.high),
+                felt(pubKeyETHy.low),
+                felt(pubKeyETHy.high),
+            ];
+        }
+        default:
+            return felt(val);
+    }
+}
+/**
+ * Parse tuple type string to array of known objects
+ * @param element request element
+ * @param typeStr tuple type string
+ * @returns Tupled[]
+ */
+function parseTuple(element, typeStr) {
+    const memberTypes = extractTupleMemberTypes(typeStr);
+    const elements = Object.values(element);
+    if (elements.length !== memberTypes.length) {
+        throw Error(`ParseTuple: provided and expected abi tuple size do not match.
+      provided: ${elements} 
+      expected: ${memberTypes}`);
+    }
+    return memberTypes.map((it, dx) => {
+        return {
+            element: elements[dx],
+            type: it.type ?? it,
+        };
+    });
+}
+function parseByteArray(element) {
+    const myByteArray = byteArrayFromString(element);
+    return [
+        myByteArray.data.length.toString(),
+        ...myByteArray.data.map((bn) => bn.toString()),
+        myByteArray.pending_word.toString(),
+        myByteArray.pending_word_len.toString(),
+    ];
+}
+/**
+ * Deep parse of the object that has been passed to the method
+ *
+ * @param element - element that needs to be parsed
+ * @param type  - name of the method
+ * @param structs - structs from abi
+ * @param enums - enums from abi
+ * @return {string | string[]} - parsed arguments in format that contract is expecting
+ */
+function parseCalldataValue(element, type, structs, enums) {
+    if (element === undefined) {
+        throw Error(`Missing parameter for type ${type}`);
+    }
+    // value is Array
+    if (Array.isArray(element)) {
+        const result = [];
+        result.push(felt(element.length)); // Add length to array
+        const arrayType = getArrayType(type);
+        return element.reduce((acc, it) => {
+            return acc.concat(parseCalldataValue(it, arrayType, structs, enums));
+        }, result);
+    }
+    // checking if the passed element is struct
+    if (structs[type] && structs[type].members.length) {
+        if (CairoUint256.isAbiType(type)) {
+            return new CairoUint256(element).toApiRequest();
+        }
+        if (CairoUint512.isAbiType(type)) {
+            return new CairoUint512(element).toApiRequest();
+        }
+        if (type === 'core::starknet::eth_address::EthAddress')
+            return parseBaseTypes(type, element);
+        if (type === 'core::byte_array::ByteArray')
+            return parseByteArray(element);
+        const { members } = structs[type];
+        const subElement = element;
+        return members.reduce((acc, it) => {
+            return acc.concat(parseCalldataValue(subElement[it.name], it.type, structs, enums));
+        }, []);
+    }
+    // check if abi element is tuple
+    if (isTypeTuple(type)) {
+        const tupled = parseTuple(element, type);
+        return tupled.reduce((acc, it) => {
+            const parsedData = parseCalldataValue(it.element, it.type, structs, enums);
+            return acc.concat(parsedData);
+        }, []);
+    }
+    // check if u256 C1v0
+    if (CairoUint256.isAbiType(type)) {
+        return new CairoUint256(element).toApiRequest();
+    }
+    // check if u512
+    if (CairoUint512.isAbiType(type)) {
+        return new CairoUint512(element).toApiRequest();
+    }
+    // check if Enum
+    if (isTypeEnum(type, enums)) {
+        const { variants } = enums[type];
+        // Option Enum
+        if (isTypeOption(type)) {
+            const myOption = element;
+            if (myOption.isSome()) {
+                const listTypeVariant = variants.find((variant) => variant.name === 'Some');
+                if (typeof listTypeVariant === 'undefined') {
+                    throw Error(`Error in abi : Option has no 'Some' variant.`);
+                }
+                const typeVariantSome = listTypeVariant.type;
+                if (typeVariantSome === '()') {
+                    return CairoOptionVariant.Some.toString();
+                }
+                const parsedParameter = parseCalldataValue(myOption.unwrap(), typeVariantSome, structs, enums);
+                if (Array.isArray(parsedParameter)) {
+                    return [CairoOptionVariant.Some.toString(), ...parsedParameter];
+                }
+                return [CairoOptionVariant.Some.toString(), parsedParameter];
+            }
+            return CairoOptionVariant.None.toString();
+        }
+        // Result Enum
+        if (isTypeResult(type)) {
+            const myResult = element;
+            if (myResult.isOk()) {
+                const listTypeVariant = variants.find((variant) => variant.name === 'Ok');
+                if (typeof listTypeVariant === 'undefined') {
+                    throw Error(`Error in abi : Result has no 'Ok' variant.`);
+                }
+                const typeVariantOk = listTypeVariant.type;
+                if (typeVariantOk === '()') {
+                    return CairoResultVariant.Ok.toString();
+                }
+                const parsedParameter = parseCalldataValue(myResult.unwrap(), typeVariantOk, structs, enums);
+                if (Array.isArray(parsedParameter)) {
+                    return [CairoResultVariant.Ok.toString(), ...parsedParameter];
+                }
+                return [CairoResultVariant.Ok.toString(), parsedParameter];
+            }
+            // is Result::Err
+            const listTypeVariant = variants.find((variant) => variant.name === 'Err');
+            if (typeof listTypeVariant === 'undefined') {
+                throw Error(`Error in abi : Result has no 'Err' variant.`);
+            }
+            const typeVariantErr = listTypeVariant.type;
+            if (typeVariantErr === '()') {
+                return CairoResultVariant.Err.toString();
+            }
+            const parsedParameter = parseCalldataValue(myResult.unwrap(), typeVariantErr, structs, enums);
+            if (Array.isArray(parsedParameter)) {
+                return [CairoResultVariant.Err.toString(), ...parsedParameter];
+            }
+            return [CairoResultVariant.Err.toString(), parsedParameter];
+        }
+        // Custom Enum
+        const myEnum = element;
+        const activeVariant = myEnum.activeVariant();
+        const listTypeVariant = variants.find((variant) => variant.name === activeVariant);
+        if (typeof listTypeVariant === 'undefined') {
+            throw Error(`Not find in abi : Enum has no '${activeVariant}' variant.`);
+        }
+        const typeActiveVariant = listTypeVariant.type;
+        const numActiveVariant = variants.findIndex((variant) => variant.name === activeVariant); // can not fail due to check of listTypeVariant
+        if (typeActiveVariant === '()') {
+            return numActiveVariant.toString();
+        }
+        const parsedParameter = parseCalldataValue(myEnum.unwrap(), typeActiveVariant, structs, enums);
+        if (Array.isArray(parsedParameter)) {
+            return [numActiveVariant.toString(), ...parsedParameter];
+        }
+        return [numActiveVariant.toString(), parsedParameter];
+    }
+    if (typeof element === 'object') {
+        throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
+    }
+    return parseBaseTypes(type, element);
+}
+/**
+ * Parse one field of the calldata by using input field from the abi for that method
+ *
+ * @param argsIterator - Iterator for value of the field
+ * @param input  - input(field) information from the abi that will be used to parse the data
+ * @param structs - structs from abi
+ * @param enums - enums from abi
+ * @return {string | string[]} - parsed arguments in format that contract is expecting
+ */
+export function parseCalldataField(argsIterator, input, structs, enums) {
+    const { name, type } = input;
+    let { value } = argsIterator.next();
+    switch (true) {
+        // Array
+        case isTypeArray(type):
+            if (!Array.isArray(value) && !isText(value)) {
+                throw Error(`ABI expected parameter ${name} to be array or long string, got ${value}`);
+            }
+            if (isString(value)) {
+                // long string match cairo felt*
+                value = splitLongString(value);
+            }
+            return parseCalldataValue(value, input.type, structs, enums);
+        case type === 'core::starknet::eth_address::EthAddress':
+            return parseBaseTypes(type, value);
+        // Struct or Tuple
+        case isTypeStruct(type, structs) ||
+            isTypeTuple(type) ||
+            CairoUint256.isAbiType(type) ||
+            CairoUint256.isAbiType(type):
+            return parseCalldataValue(value, type, structs, enums);
+        // Enums
+        case isTypeEnum(type, enums):
+            return parseCalldataValue(value, type, structs, enums);
+        // Felt or unhandled
+        default:
+            return parseBaseTypes(type, value);
+    }
+}

package/js/src/static_dependencies/starknet/utils/calldata/responseParser.d.ts

@@ -0,0 +1,11 @@
+import { AbiEntry, AbiEnums, AbiStructs, Args, EventEntry, ParsedStruct } from '../../types/index.js';
+/**
+ * Parse elements of the response and structuring them into one field by using output property from the abi for that method
+ *
+ * @param responseIterator - iterator of the response
+ * @param output - output(field) information from the abi that will be used to parse the data
+ * @param structs - structs from abi
+ * @param parsedResult
+ * @return - parsed response corresponding to the abi structure of the field
+ */
+export default function responseParser(responseIterator: Iterator<string>, output: AbiEntry | EventEntry, structs?: AbiStructs, enums?: AbiEnums, parsedResult?: Args | ParsedStruct): any;