starknet 6.9.0 → 6.10.1

package/dist/utils/calldata/requestParser.cjs

@@ -0,0 +1,204 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseCalldataField = parseCalldataField;
+var _uint = require("../cairoDataTypes/uint256.cjs");
+var _uint2 = require("../cairoDataTypes/uint512.cjs");
+var _encode = require("../encode.cjs");
+var _num = require("../num.cjs");
+var _shortString = require("../shortString.cjs");
+var _byteArray = require("./byteArray.cjs");
+var _cairo = require("./cairo.cjs");
+var _enum = require("./enum/index.cjs");
+var _tuple = _interopRequireDefault(require("./tuple.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function parseBaseTypes(type, val) {
+  switch (true) {
+    case _uint.CairoUint256.isAbiType(type):
+      return new _uint.CairoUint256(val).toApiRequest();
+    case _uint2.CairoUint512.isAbiType(type):
+      return new _uint2.CairoUint512(val).toApiRequest();
+    case (0, _cairo.isTypeBytes31)(type):
+      return (0, _shortString.encodeShortString)(val.toString());
+    case (0, _cairo.isTypeSecp256k1Point)(type):
+      {
+        const pubKeyETH = (0, _encode.removeHexPrefix)((0, _num.toHex)(val)).padStart(128, "0");
+        const pubKeyETHy = (0, _cairo.uint256)((0, _encode.addHexPrefix)(pubKeyETH.slice(-64)));
+        const pubKeyETHx = (0, _cairo.uint256)((0, _encode.addHexPrefix)(pubKeyETH.slice(0, -64)));
+        return [(0, _cairo.felt)(pubKeyETHx.low), (0, _cairo.felt)(pubKeyETHx.high), (0, _cairo.felt)(pubKeyETHy.low), (0, _cairo.felt)(pubKeyETHy.high)];
+      }
+    default:
+      return (0, _cairo.felt)(val);
+  }
+}
+function parseTuple(element, typeStr) {
+  const memberTypes = (0, _tuple.default)(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 = (0, _byteArray.byteArrayFromString)(element);
+  return [myByteArray.data.length.toString(), ...myByteArray.data.map(bn => bn.toString()), myByteArray.pending_word.toString(), myByteArray.pending_word_len.toString()];
+}
+function parseCalldataValue(element, type, structs, enums) {
+  if (element === void 0) {
+    throw Error(`Missing parameter for type ${type}`);
+  }
+  if (Array.isArray(element)) {
+    const result = [];
+    result.push((0, _cairo.felt)(element.length));
+    const arrayType = (0, _cairo.getArrayType)(type);
+    return element.reduce((acc, it) => {
+      return acc.concat(parseCalldataValue(it, arrayType, structs, enums));
+    }, result);
+  }
+  if (structs[type] && structs[type].members.length) {
+    if (_uint.CairoUint256.isAbiType(type)) {
+      return new _uint.CairoUint256(element).toApiRequest();
+    }
+    if (_uint2.CairoUint512.isAbiType(type)) {
+      return new _uint2.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));
+    }, []);
+  }
+  if ((0, _cairo.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);
+    }, []);
+  }
+  if (_uint.CairoUint256.isAbiType(type)) {
+    return new _uint.CairoUint256(element).toApiRequest();
+  }
+  if (_uint2.CairoUint512.isAbiType(type)) {
+    return new _uint2.CairoUint512(element).toApiRequest();
+  }
+  if ((0, _cairo.isTypeEnum)(type, enums)) {
+    const {
+      variants
+    } = enums[type];
+    if ((0, _cairo.isTypeOption)(type)) {
+      const myOption = element;
+      if (myOption.isSome()) {
+        const listTypeVariant2 = variants.find(variant => variant.name === "Some");
+        if (typeof listTypeVariant2 === "undefined") {
+          throw Error(`Error in abi : Option has no 'Some' variant.`);
+        }
+        const typeVariantSome = listTypeVariant2.type;
+        if (typeVariantSome === "()") {
+          return _enum.CairoOptionVariant.Some.toString();
+        }
+        const parsedParameter2 = parseCalldataValue(myOption.unwrap(), typeVariantSome, structs, enums);
+        if (Array.isArray(parsedParameter2)) {
+          return [_enum.CairoOptionVariant.Some.toString(), ...parsedParameter2];
+        }
+        return [_enum.CairoOptionVariant.Some.toString(), parsedParameter2];
+      }
+      return _enum.CairoOptionVariant.None.toString();
+    }
+    if ((0, _cairo.isTypeResult)(type)) {
+      const myResult = element;
+      if (myResult.isOk()) {
+        const listTypeVariant3 = variants.find(variant => variant.name === "Ok");
+        if (typeof listTypeVariant3 === "undefined") {
+          throw Error(`Error in abi : Result has no 'Ok' variant.`);
+        }
+        const typeVariantOk = listTypeVariant3.type;
+        if (typeVariantOk === "()") {
+          return _enum.CairoResultVariant.Ok.toString();
+        }
+        const parsedParameter3 = parseCalldataValue(myResult.unwrap(), typeVariantOk, structs, enums);
+        if (Array.isArray(parsedParameter3)) {
+          return [_enum.CairoResultVariant.Ok.toString(), ...parsedParameter3];
+        }
+        return [_enum.CairoResultVariant.Ok.toString(), parsedParameter3];
+      }
+      const listTypeVariant2 = variants.find(variant => variant.name === "Err");
+      if (typeof listTypeVariant2 === "undefined") {
+        throw Error(`Error in abi : Result has no 'Err' variant.`);
+      }
+      const typeVariantErr = listTypeVariant2.type;
+      if (typeVariantErr === "()") {
+        return _enum.CairoResultVariant.Err.toString();
+      }
+      const parsedParameter2 = parseCalldataValue(myResult.unwrap(), typeVariantErr, structs, enums);
+      if (Array.isArray(parsedParameter2)) {
+        return [_enum.CairoResultVariant.Err.toString(), ...parsedParameter2];
+      }
+      return [_enum.CairoResultVariant.Err.toString(), parsedParameter2];
+    }
+    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);
+    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 ((0, _cairo.isTypeNonZero)(type)) {
+    return parseBaseTypes((0, _cairo.getArrayType)(type), element);
+  }
+  if (typeof element === "object") {
+    throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
+  }
+  return parseBaseTypes(type, element);
+}
+function parseCalldataField(argsIterator, input, structs, enums) {
+  const {
+    name,
+    type
+  } = input;
+  let {
+    value
+  } = argsIterator.next();
+  switch (true) {
+    case (0, _cairo.isTypeArray)(type):
+      if (!Array.isArray(value) && !(0, _shortString.isText)(value)) {
+        throw Error(`ABI expected parameter ${name} to be array or long string, got ${value}`);
+      }
+      if ((0, _shortString.isString)(value)) {
+        value = (0, _shortString.splitLongString)(value);
+      }
+      return parseCalldataValue(value, input.type, structs, enums);
+    case (0, _cairo.isTypeNonZero)(type):
+      return parseBaseTypes((0, _cairo.getArrayType)(type), value);
+    case type === "core::starknet::eth_address::EthAddress":
+      return parseBaseTypes(type, value);
+    case (0, _cairo.isTypeStruct)(type, structs) || (0, _cairo.isTypeTuple)(type) || _uint.CairoUint256.isAbiType(type) || _uint.CairoUint256.isAbiType(type):
+      return parseCalldataValue(value, type, structs, enums);
+    case (0, _cairo.isTypeEnum)(type, enums):
+      return parseCalldataValue(value, type, structs, enums);
+    default:
+      return parseBaseTypes(type, value);
+  }
+}

package/dist/utils/calldata/requestParser.d.ts

@@ -0,0 +1,11 @@
+import { AbiEntry, AbiEnums, AbiStructs } from '../../types';
+/**
+ * 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/dist/utils/calldata/requestParser.mjs

@@ -0,0 +1,231 @@
+import { CairoUint256 } from "../cairoDataTypes/uint256.mjs";
+import { CairoUint512 } from "../cairoDataTypes/uint512.mjs";
+import { addHexPrefix, removeHexPrefix } from "../encode.mjs";
+import { toHex } from "../num.mjs";
+import { encodeShortString, isString, isText, splitLongString } from "../shortString.mjs";
+import { byteArrayFromString } from "./byteArray.mjs";
+import {
+  felt,
+  getArrayType,
+  isTypeArray,
+  isTypeBytes31,
+  isTypeEnum,
+  isTypeNonZero,
+  isTypeOption,
+  isTypeResult,
+  isTypeSecp256k1Point,
+  isTypeStruct,
+  isTypeTuple,
+  uint256
+} from "./cairo.mjs";
+import {
+  CairoOptionVariant,
+  CairoResultVariant
+} from "./enum/index.mjs";
+import extractTupleMemberTypes from "./tuple.mjs";
+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);
+  }
+}
+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()
+  ];
+}
+function parseCalldataValue(element, type, structs, enums) {
+  if (element === void 0) {
+    throw Error(`Missing parameter for type ${type}`);
+  }
+  if (Array.isArray(element)) {
+    const result = [];
+    result.push(felt(element.length));
+    const arrayType = getArrayType(type);
+    return element.reduce((acc, it) => {
+      return acc.concat(parseCalldataValue(it, arrayType, structs, enums));
+    }, result);
+  }
+  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));
+    }, []);
+  }
+  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);
+    }, []);
+  }
+  if (CairoUint256.isAbiType(type)) {
+    return new CairoUint256(element).toApiRequest();
+  }
+  if (CairoUint512.isAbiType(type)) {
+    return new CairoUint512(element).toApiRequest();
+  }
+  if (isTypeEnum(type, enums)) {
+    const { variants } = enums[type];
+    if (isTypeOption(type)) {
+      const myOption = element;
+      if (myOption.isSome()) {
+        const listTypeVariant2 = variants.find((variant) => variant.name === "Some");
+        if (typeof listTypeVariant2 === "undefined") {
+          throw Error(`Error in abi : Option has no 'Some' variant.`);
+        }
+        const typeVariantSome = listTypeVariant2.type;
+        if (typeVariantSome === "()") {
+          return CairoOptionVariant.Some.toString();
+        }
+        const parsedParameter2 = parseCalldataValue(
+          myOption.unwrap(),
+          typeVariantSome,
+          structs,
+          enums
+        );
+        if (Array.isArray(parsedParameter2)) {
+          return [CairoOptionVariant.Some.toString(), ...parsedParameter2];
+        }
+        return [CairoOptionVariant.Some.toString(), parsedParameter2];
+      }
+      return CairoOptionVariant.None.toString();
+    }
+    if (isTypeResult(type)) {
+      const myResult = element;
+      if (myResult.isOk()) {
+        const listTypeVariant3 = variants.find((variant) => variant.name === "Ok");
+        if (typeof listTypeVariant3 === "undefined") {
+          throw Error(`Error in abi : Result has no 'Ok' variant.`);
+        }
+        const typeVariantOk = listTypeVariant3.type;
+        if (typeVariantOk === "()") {
+          return CairoResultVariant.Ok.toString();
+        }
+        const parsedParameter3 = parseCalldataValue(
+          myResult.unwrap(),
+          typeVariantOk,
+          structs,
+          enums
+        );
+        if (Array.isArray(parsedParameter3)) {
+          return [CairoResultVariant.Ok.toString(), ...parsedParameter3];
+        }
+        return [CairoResultVariant.Ok.toString(), parsedParameter3];
+      }
+      const listTypeVariant2 = variants.find((variant) => variant.name === "Err");
+      if (typeof listTypeVariant2 === "undefined") {
+        throw Error(`Error in abi : Result has no 'Err' variant.`);
+      }
+      const typeVariantErr = listTypeVariant2.type;
+      if (typeVariantErr === "()") {
+        return CairoResultVariant.Err.toString();
+      }
+      const parsedParameter2 = parseCalldataValue(myResult.unwrap(), typeVariantErr, structs, enums);
+      if (Array.isArray(parsedParameter2)) {
+        return [CairoResultVariant.Err.toString(), ...parsedParameter2];
+      }
+      return [CairoResultVariant.Err.toString(), parsedParameter2];
+    }
+    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);
+    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 (isTypeNonZero(type)) {
+    return parseBaseTypes(getArrayType(type), element);
+  }
+  if (typeof element === "object") {
+    throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
+  }
+  return parseBaseTypes(type, element);
+}
+export function parseCalldataField(argsIterator, input, structs, enums) {
+  const { name, type } = input;
+  let { value } = argsIterator.next();
+  switch (true) {
+    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)) {
+        value = splitLongString(value);
+      }
+      return parseCalldataValue(value, input.type, structs, enums);
+    case isTypeNonZero(type):
+      return parseBaseTypes(getArrayType(type), value);
+    case type === "core::starknet::eth_address::EthAddress":
+      return parseBaseTypes(type, value);
+    case (isTypeStruct(type, structs) || isTypeTuple(type) || CairoUint256.isAbiType(type) || CairoUint256.isAbiType(type)):
+      return parseCalldataValue(value, type, structs, enums);
+    case isTypeEnum(type, enums):
+      return parseCalldataValue(
+        value,
+        type,
+        structs,
+        enums
+      );
+    default:
+      return parseBaseTypes(type, value);
+  }
+}

package/dist/utils/calldata/responseParser.cjs

@@ -0,0 +1,200 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = responseParser;
+var _uint = require("../cairoDataTypes/uint256.cjs");
+var _uint2 = require("../cairoDataTypes/uint512.cjs");
+var _encode = require("../encode.cjs");
+var _num = require("../num.cjs");
+var _shortString = require("../shortString.cjs");
+var _byteArray = require("./byteArray.cjs");
+var _cairo = require("./cairo.cjs");
+var _enum = require("./enum/index.cjs");
+var _tuple = _interopRequireDefault(require("./tuple.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function parseBaseTypes(type, it) {
+  let temp;
+  switch (true) {
+    case (0, _cairo.isTypeBool)(type):
+      temp = it.next().value;
+      return Boolean(BigInt(temp));
+    case _uint.CairoUint256.isAbiType(type):
+      const low = it.next().value;
+      const high = it.next().value;
+      return new _uint.CairoUint256(low, high).toBigInt();
+    case _uint2.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 _uint2.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 (0, _shortString.decodeShortString)(temp);
+    case (0, _cairo.isTypeSecp256k1Point)(type):
+      const xLow = (0, _encode.removeHexPrefix)(it.next().value).padStart(32, "0");
+      const xHigh = (0, _encode.removeHexPrefix)(it.next().value).padStart(32, "0");
+      const yLow = (0, _encode.removeHexPrefix)(it.next().value).padStart(32, "0");
+      const yHigh = (0, _encode.removeHexPrefix)(it.next().value).padStart(32, "0");
+      const pubK = BigInt((0, _encode.addHexPrefix)(xHigh + xLow + yHigh + yLow));
+      return pubK;
+    default:
+      temp = it.next().value;
+      return BigInt(temp);
+  }
+}
+function parseResponseValue(responseIterator, element, structs, enums) {
+  if (element.type === "()") {
+    return {};
+  }
+  if (_uint.CairoUint256.isAbiType(element.type)) {
+    const low = responseIterator.next().value;
+    const high = responseIterator.next().value;
+    return new _uint.CairoUint256(low, high).toBigInt();
+  }
+  if (_uint2.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 _uint2.CairoUint512(limb0, limb1, limb2, limb3).toBigInt();
+  }
+  if ((0, _cairo.isTypeByteArray)(element.type)) {
+    const parsedBytes31Arr = [];
+    const bytes31ArrLen = BigInt(responseIterator.next().value);
+    while (parsedBytes31Arr.length < bytes31ArrLen) {
+      parsedBytes31Arr.push((0, _num.toHex)(responseIterator.next().value));
+    }
+    const pending_word = (0, _num.toHex)(responseIterator.next().value);
+    const pending_word_len = BigInt(responseIterator.next().value);
+    const myByteArray = {
+      data: parsedBytes31Arr,
+      pending_word,
+      pending_word_len
+    };
+    return (0, _byteArray.stringFromByteArray)(myByteArray);
+  }
+  if ((0, _cairo.isTypeArray)(element.type)) {
+    const parsedDataArr = [];
+    const el = {
+      name: "",
+      type: (0, _cairo.getArrayType)(element.type)
+    };
+    const len = BigInt(responseIterator.next().value);
+    while (parsedDataArr.length < len) {
+      parsedDataArr.push(parseResponseValue(responseIterator, el, structs, enums));
+    }
+    return parsedDataArr;
+  }
+  if ((0, _cairo.isTypeNonZero)(element.type)) {
+    const el = {
+      name: "",
+      type: (0, _cairo.getArrayType)(element.type)
+    };
+    return parseResponseValue(responseIterator, el, structs, enums);
+  }
+  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;
+    }, {});
+  }
+  if (enums && element.type in enums && enums[element.type]) {
+    const variantNum = Number(responseIterator.next().value);
+    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] = void 0;
+      return acc;
+    }, {});
+    if (element.type.startsWith("core::option::Option")) {
+      const content = variantNum === _enum.CairoOptionVariant.Some ? rawEnum.Some : void 0;
+      return new _enum.CairoOption(variantNum, content);
+    }
+    if (element.type.startsWith("core::result::Result")) {
+      let content;
+      if (variantNum === _enum.CairoResultVariant.Ok) {
+        content = rawEnum.Ok;
+      } else {
+        content = rawEnum.Err;
+      }
+      return new _enum.CairoResult(variantNum, content);
+    }
+    const customEnum = new _enum.CairoCustomEnum(rawEnum);
+    return customEnum;
+  }
+  if ((0, _cairo.isTypeTuple)(element.type)) {
+    const memberTypes = (0, _tuple.default)(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;
+    }, {});
+  }
+  if ((0, _cairo.isTypeArray)(element.type)) {
+    const parsedDataArr = [];
+    const el = {
+      name: "",
+      type: (0, _cairo.getArrayType)(element.type)
+    };
+    const len = BigInt(responseIterator.next().value);
+    while (parsedDataArr.length < len) {
+      parsedDataArr.push(parseResponseValue(responseIterator, el, structs, enums));
+    }
+    return parsedDataArr;
+  }
+  return parseBaseTypes(element.type, responseIterator);
+}
+function responseParser(responseIterator, output, structs, enums, parsedResult) {
+  const {
+    name,
+    type
+  } = output;
+  let temp;
+  switch (true) {
+    case (0, _cairo.isLen)(name):
+      temp = responseIterator.next().value;
+      return BigInt(temp);
+    case structs && type in structs || (0, _cairo.isTypeTuple)(type):
+      return parseResponseValue(responseIterator, output, structs, enums);
+    case enums && (0, _cairo.isTypeEnum)(type, enums):
+      return parseResponseValue(responseIterator, output, structs, enums);
+    case (0, _cairo.isTypeArray)(type):
+      if ((0, _cairo.isCairo1Type)(type)) {
+        return parseResponseValue(responseIterator, output, structs, enums);
+      }
+      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;
+    case (0, _cairo.isTypeNonZero)(type):
+      return parseResponseValue(responseIterator, output, structs, enums);
+    default:
+      return parseBaseTypes(type, responseIterator);
+  }
+}

package/dist/utils/calldata/responseParser.d.ts

@@ -0,0 +1,11 @@
+import { AbiEntry, AbiEnums, AbiStructs, Args, EventEntry, ParsedStruct } from '../../types';
+/**
+ * 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;