ccxt-ir 4.9.32 → 4.11.0

package/js/src/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/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/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/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;

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

@@ -0,0 +1,214 @@
+// ----------------------------------------------------------------------------
+
+// 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 { decodeShortString } from '../shortString.js';
+import { stringFromByteArray } from './byteArray.js';
+import { getArrayType, isCairo1Type, isLen, isTypeArray, isTypeBool, isTypeByteArray, isTypeEnum, isTypeSecp256k1Point, isTypeTuple, } from './cairo.js';
+import { CairoCustomEnum, CairoOption, CairoOptionVariant, CairoResult, CairoResultVariant, } from './enum/index.js';
+import extractTupleMemberTypes from './tuple.js';
+/**
+ * Parse base types
+ * @param type type of element
+ * @param it iterator
+ * @returns bigint | boolean
+ */
+function parseBaseTypes(type, it) {
+    let temp;
+    switch (true) {
+        case isTypeBool(type):
+            temp = it.next().value;
+            return Boolean(BigInt(temp));
+        case CairoUint256.isAbiType(type):
+            const low = it.next().value;
+            const high = it.next().value;
+            return new CairoUint256(low, high).toBigInt();
+        case CairoUint512.isAbiType(type):
+            const limb0 = it.next().value;
+            const limb1 = it.next().value;
+            const limb2 = it.next().value;
+            const limb3 = it.next().value;
+            return new CairoUint512(limb0, limb1, limb2, limb3).toBigInt();
+        case type === 'core::starknet::eth_address::EthAddress':
+            temp = it.next().value;
+            return BigInt(temp);
+        case type === 'core::bytes_31::bytes31':
+            temp = it.next().value;
+            return decodeShortString(temp);
+        case isTypeSecp256k1Point(type):
+            const xLow = removeHexPrefix(it.next().value).padStart(32, '0');
+            const xHigh = removeHexPrefix(it.next().value).padStart(32, '0');
+            const yLow = removeHexPrefix(it.next().value).padStart(32, '0');
+            const yHigh = removeHexPrefix(it.next().value).padStart(32, '0');
+            const pubK = BigInt(addHexPrefix(xHigh + xLow + yHigh + yLow));
+            return pubK;
+        default:
+            temp = it.next().value;
+            return BigInt(temp);
+    }
+}
+/**
+ * Parse of the response elements that are converted to Object (Struct) by using the abi
+ *
+ * @param responseIterator - iterator of the response
+ * @param element - element of the field {name: string, type: string}
+ * @param structs - structs from abi
+ * @param enums
+ * @return {any} - parsed arguments in format that contract is expecting
+ */
+function parseResponseValue(responseIterator, element, structs, enums) {
+    if (element.type === '()') {
+        return {};
+    }
+    // type uint256 struct (c1v2)
+    if (CairoUint256.isAbiType(element.type)) {
+        const low = responseIterator.next().value;
+        const high = responseIterator.next().value;
+        return new CairoUint256(low, high).toBigInt();
+    }
+    // type uint512 struct
+    if (CairoUint512.isAbiType(element.type)) {
+        const limb0 = responseIterator.next().value;
+        const limb1 = responseIterator.next().value;
+        const limb2 = responseIterator.next().value;
+        const limb3 = responseIterator.next().value;
+        return new CairoUint512(limb0, limb1, limb2, limb3).toBigInt();
+    }
+    // type C1 ByteArray struct, representing a LongString
+    if (isTypeByteArray(element.type)) {
+        const parsedBytes31Arr = [];
+        const bytes31ArrLen = BigInt(responseIterator.next().value);
+        while (parsedBytes31Arr.length < bytes31ArrLen) {
+            parsedBytes31Arr.push(toHex(responseIterator.next().value));
+        }
+        const pending_word = toHex(responseIterator.next().value);
+        const pending_word_len = BigInt(responseIterator.next().value);
+        const myByteArray = {
+            data: parsedBytes31Arr,
+            pending_word,
+            pending_word_len,
+        };
+        return stringFromByteArray(myByteArray);
+    }
+    // type c1 array
+    if (isTypeArray(element.type)) {
+        // eslint-disable-next-line no-case-declarations
+        const parsedDataArr = [];
+        const el = { name: '', type: getArrayType(element.type) };
+        const len = BigInt(responseIterator.next().value); // get length
+        while (parsedDataArr.length < len) {
+            parsedDataArr.push(parseResponseValue(responseIterator, el, structs, enums));
+        }
+        return parsedDataArr;
+    }
+    // type struct
+    if (structs && element.type in structs && structs[element.type]) {
+        if (element.type === 'core::starknet::eth_address::EthAddress') {
+            return parseBaseTypes(element.type, responseIterator);
+        }
+        return structs[element.type].members.reduce((acc, el) => {
+            acc[el.name] = parseResponseValue(responseIterator, el, structs, enums);
+            return acc;
+        }, {});
+    }
+    // type Enum (only CustomEnum)
+    if (enums && element.type in enums && enums[element.type]) {
+        const variantNum = Number(responseIterator.next().value); // get variant number
+        const rawEnum = enums[element.type].variants.reduce((acc, variant, num) => {
+            if (num === variantNum) {
+                acc[variant.name] = parseResponseValue(responseIterator, { name: '', type: variant.type }, structs, enums);
+                return acc;
+            }
+            acc[variant.name] = undefined;
+            return acc;
+        }, {});
+        // Option
+        if (element.type.startsWith('core::option::Option')) {
+            const content = variantNum === CairoOptionVariant.Some ? rawEnum.Some : undefined;
+            return new CairoOption(variantNum, content);
+        }
+        // Result
+        if (element.type.startsWith('core::result::Result')) {
+            let content;
+            if (variantNum === CairoResultVariant.Ok) {
+                content = rawEnum.Ok;
+            }
+            else {
+                content = rawEnum.Err;
+            }
+            return new CairoResult(variantNum, content);
+        }
+        // Cairo custom Enum
+        const customEnum = new CairoCustomEnum(rawEnum);
+        return customEnum;
+    }
+    // type tuple
+    if (isTypeTuple(element.type)) {
+        const memberTypes = extractTupleMemberTypes(element.type);
+        return memberTypes.reduce((acc, it, idx) => {
+            const name = it?.name ? it.name : idx;
+            const type = it?.type ? it.type : it;
+            const el = { name, type };
+            acc[name] = parseResponseValue(responseIterator, el, structs, enums);
+            return acc;
+        }, {});
+    }
+    // type c1 array
+    if (isTypeArray(element.type)) {
+        // eslint-disable-next-line no-case-declarations
+        const parsedDataArr = [];
+        const el = { name: '', type: getArrayType(element.type) };
+        const len = BigInt(responseIterator.next().value); // get length
+        while (parsedDataArr.length < len) {
+            parsedDataArr.push(parseResponseValue(responseIterator, el, structs, enums));
+        }
+        return parsedDataArr;
+    }
+    // base type
+    return parseBaseTypes(element.type, responseIterator);
+}
+/**
+ * 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, output, structs, enums, parsedResult) {
+    const { name, type } = output;
+    let temp;
+    switch (true) {
+        case isLen(name):
+            temp = responseIterator.next().value;
+            return BigInt(temp);
+        case (structs && type in structs) || isTypeTuple(type):
+            return parseResponseValue(responseIterator, output, structs, enums);
+        case enums && isTypeEnum(type, enums):
+            return parseResponseValue(responseIterator, output, structs, enums);
+        case isTypeArray(type):
+            // C1 Array
+            if (isCairo1Type(type)) {
+                return parseResponseValue(responseIterator, output, structs, enums);
+            }
+            // C0 Array
+            // eslint-disable-next-line no-case-declarations
+            const parsedDataArr = [];
+            if (parsedResult && parsedResult[`${name}_len`]) {
+                const arrLen = parsedResult[`${name}_len`];
+                while (parsedDataArr.length < arrLen) {
+                    parsedDataArr.push(parseResponseValue(responseIterator, { name, type: output.type.replace('*', '') }, structs, enums));
+                }
+            }
+            return parsedDataArr;
+        default:
+            return parseBaseTypes(type, responseIterator);
+    }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Convert tuple string definition into object like definition
+ * @param type tuple string definition
+ * @returns object like tuple
+ */
+export default function extractTupleMemberTypes(type: string): (string | object)[];