starknet 6.9.0 → 6.10.1

package/dist/utils/calldata/index.cjs

@@ -0,0 +1,272 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cairo = exports.byteArray = exports.CallData = void 0;
+Object.defineProperty(exports, "parseCalldataField", {
+  enumerable: true,
+  get: function () {
+    return _requestParser.parseCalldataField;
+  }
+});
+var _types = require("../../types/index.cjs");
+var _assert = _interopRequireDefault(require("../assert.cjs"));
+var _num = require("../num.cjs");
+var _selector = require("../hash/selector.cjs");
+var _shortString = require("../shortString.cjs");
+var _byteArray2 = _interopRequireWildcard(require("./byteArray.cjs"));
+var _byteArray = _byteArray2;
+exports.byteArray = _byteArray2;
+var _cairo2 = _interopRequireWildcard(require("./cairo.cjs"));
+var _cairo = _cairo2;
+exports.cairo = _cairo2;
+var _enum = require("./enum/index.cjs");
+var _formatter = _interopRequireDefault(require("./formatter.cjs"));
+var _parser = require("./parser/index.cjs");
+var _propertyOrder = _interopRequireDefault(require("./propertyOrder.cjs"));
+var _requestParser = require("./requestParser.cjs");
+var _responseParser = _interopRequireDefault(require("./responseParser.cjs"));
+var _validate = _interopRequireDefault(require("./validate.cjs"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class CallData {
+  abi;
+  parser;
+  structs;
+  enums;
+  constructor(abi) {
+    this.structs = CallData.getAbiStruct(abi);
+    this.enums = CallData.getAbiEnum(abi);
+    this.parser = (0, _parser.createAbiParser)(abi);
+    this.abi = this.parser.getLegacyFormat();
+  }
+  /**
+   * Validate arguments passed to the method as corresponding to the ones in the abi
+   * @param type ValidateType - type of the method
+   * @param method string - name of the method
+   * @param args ArgsOrCalldata - arguments that are passed to the method
+   */
+  validate(type, method, args = []) {
+    if (type !== _types.ValidateType.DEPLOY) {
+      const invocableFunctionNames = this.abi.filter(abi => {
+        if (abi.type !== "function") return false;
+        const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
+        return type === _types.ValidateType.INVOKE ? !isView : isView;
+      }).map(abi => abi.name);
+      (0, _assert.default)(invocableFunctionNames.includes(method), `${type === _types.ValidateType.INVOKE ? "invocable" : "viewable"} method not found in abi`);
+    }
+    const abiMethod = this.abi.find(abi => type === _types.ValidateType.DEPLOY ? abi.name === method && abi.type === "constructor" : abi.name === method && abi.type === "function");
+    if ((0, _parser.isNoConstructorValid)(method, args, abiMethod)) {
+      return;
+    }
+    const inputsLength = this.parser.methodInputsLength(abiMethod);
+    if (args.length !== inputsLength) {
+      throw Error(`Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`);
+    }
+    (0, _validate.default)(abiMethod, args, this.structs, this.enums);
+  }
+  /**
+   * Compile contract callData with abi
+   * Parse the calldata by using input fields from the abi for that method
+   * @param method string - method name
+   * @param argsCalldata RawArgs - arguments passed to the method. Can be an array of arguments (in the order of abi definition), or an object constructed in conformity with abi (in this case, the parameter can be in a wrong order).
+   * @return Calldata - parsed arguments in format that contract is expecting
+   * @example
+   * ```typescript
+   * const calldata = myCallData.compile("constructor", ["0x34a", [1, 3n]]);
+   * ```
+   * ```typescript
+   * const calldata2 = myCallData.compile("constructor", {list:[1, 3n], balance:"0x34"}); // wrong order is valid
+   * ```
+   */
+  compile(method, argsCalldata) {
+    const abiMethod = this.abi.find(abiFunction => abiFunction.name === method);
+    if ((0, _parser.isNoConstructorValid)(method, argsCalldata, abiMethod)) {
+      return [];
+    }
+    let args;
+    if (Array.isArray(argsCalldata)) {
+      args = argsCalldata;
+    } else {
+      const orderedObject = (0, _propertyOrder.default)(argsCalldata, abiMethod.inputs, this.structs, this.enums);
+      args = Object.values(orderedObject);
+      (0, _validate.default)(abiMethod, args, this.structs, this.enums);
+    }
+    const argsIterator = args[Symbol.iterator]();
+    const callArray = abiMethod.inputs.reduce((acc, input) => (0, _cairo2.isLen)(input.name) && !(0, _cairo2.isCairo1Type)(input.type) ? acc : acc.concat((0, _requestParser.parseCalldataField)(argsIterator, input, this.structs, this.enums)), []);
+    Object.defineProperty(callArray, "__compiled__", {
+      enumerable: false,
+      writable: false,
+      value: true
+    });
+    return callArray;
+  }
+  /**
+   * Compile contract callData without abi
+   * @param rawArgs RawArgs representing cairo method arguments or string array of compiled data
+   * @returns Calldata
+   */
+  static compile(rawArgs) {
+    const createTree = obj => {
+      const getEntries = (o, prefix = ".") => {
+        const oe = Array.isArray(o) ? [o.length.toString(), ...o] : o;
+        return Object.entries(oe).flatMap(([k, v]) => {
+          let value = v;
+          if (k === "entrypoint") value = (0, _selector.getSelectorFromName)(value);else if ((0, _shortString.isLongText)(value)) value = (0, _byteArray2.byteArrayFromString)(value);
+          const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
+          if ((0, _num.isBigInt)(value)) return [[`${prefix}${kk}`, (0, _cairo2.felt)(value)]];
+          if (Object(value) === value) {
+            const methodsKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(value));
+            const keys = [...Object.getOwnPropertyNames(value), ...methodsKeys];
+            if (keys.includes("isSome") && keys.includes("isNone")) {
+              const myOption = value;
+              const variantNb = myOption.isSome() ? _enum.CairoOptionVariant.Some : _enum.CairoOptionVariant.None;
+              if (myOption.isSome()) return getEntries({
+                0: variantNb,
+                1: myOption.unwrap()
+              }, `${prefix}${kk}.`);
+              return [[`${prefix}${kk}`, (0, _cairo2.felt)(variantNb)]];
+            }
+            if (keys.includes("isOk") && keys.includes("isErr")) {
+              const myResult = value;
+              const variantNb = myResult.isOk() ? _enum.CairoResultVariant.Ok : _enum.CairoResultVariant.Err;
+              return getEntries({
+                0: variantNb,
+                1: myResult.unwrap()
+              }, `${prefix}${kk}.`);
+            }
+            if (keys.includes("variant") && keys.includes("activeVariant")) {
+              const myEnum = value;
+              const activeVariant = myEnum.activeVariant();
+              const listVariants = Object.keys(myEnum.variant);
+              const activeVariantNb = listVariants.findIndex(variant => variant === activeVariant);
+              if (typeof myEnum.unwrap() === "object" && Object.keys(myEnum.unwrap()).length === 0) {
+                return [[`${prefix}${kk}`, (0, _cairo2.felt)(activeVariantNb)]];
+              }
+              return getEntries({
+                0: activeVariantNb,
+                1: myEnum.unwrap()
+              }, `${prefix}${kk}.`);
+            }
+            return getEntries(value, `${prefix}${kk}.`);
+          }
+          return [[`${prefix}${kk}`, (0, _cairo2.felt)(value)]];
+        });
+      };
+      const result = Object.fromEntries(getEntries(obj));
+      return result;
+    };
+    let callTreeArray;
+    if (!Array.isArray(rawArgs)) {
+      const callTree = createTree(rawArgs);
+      callTreeArray = Object.values(callTree);
+    } else {
+      const callObj = {
+        ...rawArgs
+      };
+      const callTree = createTree(callObj);
+      callTreeArray = Object.values(callTree);
+    }
+    Object.defineProperty(callTreeArray, "__compiled__", {
+      enumerable: false,
+      writable: false,
+      value: true
+    });
+    return callTreeArray;
+  }
+  /**
+   * Parse elements of the response array and structuring them into response object
+   * @param method string - method name
+   * @param response string[] - response from the method
+   * @return Result - parsed response corresponding to the abi
+   */
+  parse(method, response) {
+    const {
+      outputs
+    } = this.abi.find(abi => abi.name === method);
+    const responseIterator = response.flat()[Symbol.iterator]();
+    const parsed = outputs.flat().reduce((acc, output, idx) => {
+      const propName = output.name ?? idx;
+      acc[propName] = (0, _responseParser.default)(responseIterator, output, this.structs, this.enums, acc);
+      if (acc[propName] && acc[`${propName}_len`]) {
+        delete acc[`${propName}_len`];
+      }
+      return acc;
+    }, {});
+    return Object.keys(parsed).length === 1 && 0 in parsed ? parsed[0] : parsed;
+  }
+  /**
+   * Format cairo method response data to native js values based on provided format schema
+   * @param method string - cairo method name
+   * @param response string[] - cairo method response
+   * @param format object - formatter object schema
+   * @returns Result - parsed and formatted response object
+   */
+  format(method, response, format) {
+    const parsed = this.parse(method, response);
+    return (0, _formatter.default)(parsed, format);
+  }
+  /**
+   * Helper to extract structs from abi
+   * @param abi Abi
+   * @returns AbiStructs - structs from abi
+   */
+  static getAbiStruct(abi) {
+    return abi.filter(abiEntry => abiEntry.type === "struct").reduce((acc, abiEntry) => ({
+      ...acc,
+      [abiEntry.name]: abiEntry
+    }), {});
+  }
+  /**
+   * Helper to extract enums from abi
+   * @param abi Abi
+   * @returns AbiEnums - enums from abi
+   */
+  static getAbiEnum(abi) {
+    const fullEnumList = abi.filter(abiEntry => abiEntry.type === "enum").reduce((acc, abiEntry) => ({
+      ...acc,
+      [abiEntry.name]: abiEntry
+    }), {});
+    delete fullEnumList["core::bool"];
+    return fullEnumList;
+  }
+  /**
+   * Helper: Compile HexCalldata | RawCalldata | RawArgs
+   * @param rawCalldata HexCalldata | RawCalldata | RawArgs
+   * @returns Calldata
+   */
+  static toCalldata(rawCalldata = []) {
+    return CallData.compile(rawCalldata);
+  }
+  /**
+   * Helper: Convert raw to HexCalldata
+   * @param raw HexCalldata | RawCalldata | RawArgs
+   * @returns HexCalldata
+   */
+  static toHex(raw = []) {
+    const calldata = CallData.compile(raw);
+    return calldata.map(it => (0, _num.toHex)(it));
+  }
+  /**
+   * Parse the elements of a contract response and structure them into one or several Result.
+   * In Cairo 0, arrays are not supported.
+   * @param typeCairo string or string[] - Cairo type name, ex : "hello::hello::UserData"
+   * @param response string[] - serialized data corresponding to typeCairo.
+   * @return Result or Result[] - parsed response corresponding to typeData.
+   * @example
+   * const res2=helloCallData.decodeParameters("hello::hello::UserData",["0x123456","0x1"]);
+   * result = { address: 1193046n, is_claimed: true }
+   */
+  decodeParameters(typeCairo, response) {
+    const typeCairoArray = Array.isArray(typeCairo) ? typeCairo : [typeCairo];
+    const responseIterator = response.flat()[Symbol.iterator]();
+    const decodedArray = typeCairoArray.map(typeParam => (0, _responseParser.default)(responseIterator, {
+      name: "",
+      type: typeParam
+    }, this.structs, this.enums));
+    return decodedArray.length === 1 ? decodedArray[0] : decodedArray;
+  }
+}
+exports.CallData = CallData;

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

@@ -0,0 +1,90 @@
+import { Abi, AbiEnums, AbiStructs, AllowArray, ArgsOrCalldata, Calldata, HexCalldata, RawArgs, Result, ValidateType } from '../../types';
+import { AbiParserInterface } from './parser/interface';
+export * as cairo from './cairo';
+export * as byteArray from './byteArray';
+export { parseCalldataField } from './requestParser';
+export declare class CallData {
+    abi: Abi;
+    parser: AbiParserInterface;
+    protected readonly structs: AbiStructs;
+    protected readonly enums: AbiEnums;
+    constructor(abi: Abi);
+    /**
+     * Validate arguments passed to the method as corresponding to the ones in the abi
+     * @param type ValidateType - type of the method
+     * @param method string - name of the method
+     * @param args ArgsOrCalldata - arguments that are passed to the method
+     */
+    validate(type: ValidateType, method: string, args?: ArgsOrCalldata): void;
+    /**
+     * Compile contract callData with abi
+     * Parse the calldata by using input fields from the abi for that method
+     * @param method string - method name
+     * @param argsCalldata RawArgs - arguments passed to the method. Can be an array of arguments (in the order of abi definition), or an object constructed in conformity with abi (in this case, the parameter can be in a wrong order).
+     * @return Calldata - parsed arguments in format that contract is expecting
+     * @example
+     * ```typescript
+     * const calldata = myCallData.compile("constructor", ["0x34a", [1, 3n]]);
+     * ```
+     * ```typescript
+     * const calldata2 = myCallData.compile("constructor", {list:[1, 3n], balance:"0x34"}); // wrong order is valid
+     * ```
+     */
+    compile(method: string, argsCalldata: RawArgs): Calldata;
+    /**
+     * Compile contract callData without abi
+     * @param rawArgs RawArgs representing cairo method arguments or string array of compiled data
+     * @returns Calldata
+     */
+    static compile(rawArgs: RawArgs): Calldata;
+    /**
+     * Parse elements of the response array and structuring them into response object
+     * @param method string - method name
+     * @param response string[] - response from the method
+     * @return Result - parsed response corresponding to the abi
+     */
+    parse(method: string, response: string[]): Result;
+    /**
+     * Format cairo method response data to native js values based on provided format schema
+     * @param method string - cairo method name
+     * @param response string[] - cairo method response
+     * @param format object - formatter object schema
+     * @returns Result - parsed and formatted response object
+     */
+    format(method: string, response: string[], format: object): Result;
+    /**
+     * Helper to extract structs from abi
+     * @param abi Abi
+     * @returns AbiStructs - structs from abi
+     */
+    static getAbiStruct(abi: Abi): AbiStructs;
+    /**
+     * Helper to extract enums from abi
+     * @param abi Abi
+     * @returns AbiEnums - enums from abi
+     */
+    static getAbiEnum(abi: Abi): AbiEnums;
+    /**
+     * Helper: Compile HexCalldata | RawCalldata | RawArgs
+     * @param rawCalldata HexCalldata | RawCalldata | RawArgs
+     * @returns Calldata
+     */
+    static toCalldata(rawCalldata?: RawArgs): Calldata;
+    /**
+     * Helper: Convert raw to HexCalldata
+     * @param raw HexCalldata | RawCalldata | RawArgs
+     * @returns HexCalldata
+     */
+    static toHex(raw?: RawArgs): HexCalldata;
+    /**
+     * Parse the elements of a contract response and structure them into one or several Result.
+     * In Cairo 0, arrays are not supported.
+     * @param typeCairo string or string[] - Cairo type name, ex : "hello::hello::UserData"
+     * @param response string[] - serialized data corresponding to typeCairo.
+     * @return Result or Result[] - parsed response corresponding to typeData.
+     * @example
+     * const res2=helloCallData.decodeParameters("hello::hello::UserData",["0x123456","0x1"]);
+     * result = { address: 1193046n, is_claimed: true }
+     */
+    decodeParameters(typeCairo: AllowArray<string>, response: string[]): AllowArray<Result>;
+}

package/dist/utils/calldata/index.mjs

@@ -0,0 +1,276 @@
+import {
+  ValidateType
+} from "../../types/index.mjs";
+import assert from "../assert.mjs";
+import { isBigInt, toHex } from "../num.mjs";
+import { getSelectorFromName } from "../hash/selector.mjs";
+import { isLongText } from "../shortString.mjs";
+import { byteArrayFromString } from "./byteArray.mjs";
+import { felt, isCairo1Type, isLen } from "./cairo.mjs";
+import {
+  CairoOptionVariant,
+  CairoResultVariant
+} from "./enum/index.mjs";
+import formatter from "./formatter.mjs";
+import { createAbiParser, isNoConstructorValid } from "./parser/index.mjs";
+import orderPropsByAbi from "./propertyOrder.mjs";
+import { parseCalldataField } from "./requestParser.mjs";
+import responseParser from "./responseParser.mjs";
+import validateFields from "./validate.mjs";
+export * as cairo from "./cairo.mjs";
+export * as byteArray from "./byteArray.mjs";
+export { parseCalldataField } from "./requestParser.mjs";
+export class CallData {
+  abi;
+  parser;
+  structs;
+  enums;
+  constructor(abi) {
+    this.structs = CallData.getAbiStruct(abi);
+    this.enums = CallData.getAbiEnum(abi);
+    this.parser = createAbiParser(abi);
+    this.abi = this.parser.getLegacyFormat();
+  }
+  /**
+   * Validate arguments passed to the method as corresponding to the ones in the abi
+   * @param type ValidateType - type of the method
+   * @param method string - name of the method
+   * @param args ArgsOrCalldata - arguments that are passed to the method
+   */
+  validate(type, method, args = []) {
+    if (type !== ValidateType.DEPLOY) {
+      const invocableFunctionNames = this.abi.filter((abi) => {
+        if (abi.type !== "function") return false;
+        const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
+        return type === ValidateType.INVOKE ? !isView : isView;
+      }).map((abi) => abi.name);
+      assert(
+        invocableFunctionNames.includes(method),
+        `${type === ValidateType.INVOKE ? "invocable" : "viewable"} method not found in abi`
+      );
+    }
+    const abiMethod = this.abi.find(
+      (abi) => type === ValidateType.DEPLOY ? abi.name === method && abi.type === "constructor" : abi.name === method && abi.type === "function"
+    );
+    if (isNoConstructorValid(method, args, abiMethod)) {
+      return;
+    }
+    const inputsLength = this.parser.methodInputsLength(abiMethod);
+    if (args.length !== inputsLength) {
+      throw Error(
+        `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
+      );
+    }
+    validateFields(abiMethod, args, this.structs, this.enums);
+  }
+  /**
+   * Compile contract callData with abi
+   * Parse the calldata by using input fields from the abi for that method
+   * @param method string - method name
+   * @param argsCalldata RawArgs - arguments passed to the method. Can be an array of arguments (in the order of abi definition), or an object constructed in conformity with abi (in this case, the parameter can be in a wrong order).
+   * @return Calldata - parsed arguments in format that contract is expecting
+   * @example
+   * ```typescript
+   * const calldata = myCallData.compile("constructor", ["0x34a", [1, 3n]]);
+   * ```
+   * ```typescript
+   * const calldata2 = myCallData.compile("constructor", {list:[1, 3n], balance:"0x34"}); // wrong order is valid
+   * ```
+   */
+  compile(method, argsCalldata) {
+    const abiMethod = this.abi.find((abiFunction) => abiFunction.name === method);
+    if (isNoConstructorValid(method, argsCalldata, abiMethod)) {
+      return [];
+    }
+    let args;
+    if (Array.isArray(argsCalldata)) {
+      args = argsCalldata;
+    } else {
+      const orderedObject = orderPropsByAbi(
+        argsCalldata,
+        abiMethod.inputs,
+        this.structs,
+        this.enums
+      );
+      args = Object.values(orderedObject);
+      validateFields(abiMethod, args, this.structs, this.enums);
+    }
+    const argsIterator = args[Symbol.iterator]();
+    const callArray = abiMethod.inputs.reduce(
+      (acc, input) => isLen(input.name) && !isCairo1Type(input.type) ? acc : acc.concat(parseCalldataField(argsIterator, input, this.structs, this.enums)),
+      []
+    );
+    Object.defineProperty(callArray, "__compiled__", {
+      enumerable: false,
+      writable: false,
+      value: true
+    });
+    return callArray;
+  }
+  /**
+   * Compile contract callData without abi
+   * @param rawArgs RawArgs representing cairo method arguments or string array of compiled data
+   * @returns Calldata
+   */
+  static compile(rawArgs) {
+    const createTree = (obj) => {
+      const getEntries = (o, prefix = ".") => {
+        const oe = Array.isArray(o) ? [o.length.toString(), ...o] : o;
+        return Object.entries(oe).flatMap(([k, v]) => {
+          let value = v;
+          if (k === "entrypoint") value = getSelectorFromName(value);
+          else if (isLongText(value)) value = byteArrayFromString(value);
+          const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
+          if (isBigInt(value)) return [[`${prefix}${kk}`, felt(value)]];
+          if (Object(value) === value) {
+            const methodsKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(value));
+            const keys = [...Object.getOwnPropertyNames(value), ...methodsKeys];
+            if (keys.includes("isSome") && keys.includes("isNone")) {
+              const myOption = value;
+              const variantNb = myOption.isSome() ? CairoOptionVariant.Some : CairoOptionVariant.None;
+              if (myOption.isSome())
+                return getEntries({ 0: variantNb, 1: myOption.unwrap() }, `${prefix}${kk}.`);
+              return [[`${prefix}${kk}`, felt(variantNb)]];
+            }
+            if (keys.includes("isOk") && keys.includes("isErr")) {
+              const myResult = value;
+              const variantNb = myResult.isOk() ? CairoResultVariant.Ok : CairoResultVariant.Err;
+              return getEntries({ 0: variantNb, 1: myResult.unwrap() }, `${prefix}${kk}.`);
+            }
+            if (keys.includes("variant") && keys.includes("activeVariant")) {
+              const myEnum = value;
+              const activeVariant = myEnum.activeVariant();
+              const listVariants = Object.keys(myEnum.variant);
+              const activeVariantNb = listVariants.findIndex(
+                (variant) => variant === activeVariant
+              );
+              if (typeof myEnum.unwrap() === "object" && Object.keys(myEnum.unwrap()).length === 0) {
+                return [[`${prefix}${kk}`, felt(activeVariantNb)]];
+              }
+              return getEntries({ 0: activeVariantNb, 1: myEnum.unwrap() }, `${prefix}${kk}.`);
+            }
+            return getEntries(value, `${prefix}${kk}.`);
+          }
+          return [[`${prefix}${kk}`, felt(value)]];
+        });
+      };
+      const result = Object.fromEntries(getEntries(obj));
+      return result;
+    };
+    let callTreeArray;
+    if (!Array.isArray(rawArgs)) {
+      const callTree = createTree(rawArgs);
+      callTreeArray = Object.values(callTree);
+    } else {
+      const callObj = { ...rawArgs };
+      const callTree = createTree(callObj);
+      callTreeArray = Object.values(callTree);
+    }
+    Object.defineProperty(callTreeArray, "__compiled__", {
+      enumerable: false,
+      writable: false,
+      value: true
+    });
+    return callTreeArray;
+  }
+  /**
+   * Parse elements of the response array and structuring them into response object
+   * @param method string - method name
+   * @param response string[] - response from the method
+   * @return Result - parsed response corresponding to the abi
+   */
+  parse(method, response) {
+    const { outputs } = this.abi.find((abi) => abi.name === method);
+    const responseIterator = response.flat()[Symbol.iterator]();
+    const parsed = outputs.flat().reduce((acc, output, idx) => {
+      const propName = output.name ?? idx;
+      acc[propName] = responseParser(responseIterator, output, this.structs, this.enums, acc);
+      if (acc[propName] && acc[`${propName}_len`]) {
+        delete acc[`${propName}_len`];
+      }
+      return acc;
+    }, {});
+    return Object.keys(parsed).length === 1 && 0 in parsed ? parsed[0] : parsed;
+  }
+  /**
+   * Format cairo method response data to native js values based on provided format schema
+   * @param method string - cairo method name
+   * @param response string[] - cairo method response
+   * @param format object - formatter object schema
+   * @returns Result - parsed and formatted response object
+   */
+  format(method, response, format) {
+    const parsed = this.parse(method, response);
+    return formatter(parsed, format);
+  }
+  /**
+   * Helper to extract structs from abi
+   * @param abi Abi
+   * @returns AbiStructs - structs from abi
+   */
+  static getAbiStruct(abi) {
+    return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
+      (acc, abiEntry) => ({
+        ...acc,
+        [abiEntry.name]: abiEntry
+      }),
+      {}
+    );
+  }
+  /**
+   * Helper to extract enums from abi
+   * @param abi Abi
+   * @returns AbiEnums - enums from abi
+   */
+  static getAbiEnum(abi) {
+    const fullEnumList = abi.filter((abiEntry) => abiEntry.type === "enum").reduce(
+      (acc, abiEntry) => ({
+        ...acc,
+        [abiEntry.name]: abiEntry
+      }),
+      {}
+    );
+    delete fullEnumList["core::bool"];
+    return fullEnumList;
+  }
+  /**
+   * Helper: Compile HexCalldata | RawCalldata | RawArgs
+   * @param rawCalldata HexCalldata | RawCalldata | RawArgs
+   * @returns Calldata
+   */
+  static toCalldata(rawCalldata = []) {
+    return CallData.compile(rawCalldata);
+  }
+  /**
+   * Helper: Convert raw to HexCalldata
+   * @param raw HexCalldata | RawCalldata | RawArgs
+   * @returns HexCalldata
+   */
+  static toHex(raw = []) {
+    const calldata = CallData.compile(raw);
+    return calldata.map((it) => toHex(it));
+  }
+  /**
+   * Parse the elements of a contract response and structure them into one or several Result.
+   * In Cairo 0, arrays are not supported.
+   * @param typeCairo string or string[] - Cairo type name, ex : "hello::hello::UserData"
+   * @param response string[] - serialized data corresponding to typeCairo.
+   * @return Result or Result[] - parsed response corresponding to typeData.
+   * @example
+   * const res2=helloCallData.decodeParameters("hello::hello::UserData",["0x123456","0x1"]);
+   * result = { address: 1193046n, is_claimed: true }
+   */
+  decodeParameters(typeCairo, response) {
+    const typeCairoArray = Array.isArray(typeCairo) ? typeCairo : [typeCairo];
+    const responseIterator = response.flat()[Symbol.iterator]();
+    const decodedArray = typeCairoArray.map(
+      (typeParam) => responseParser(
+        responseIterator,
+        { name: "", type: typeParam },
+        this.structs,
+        this.enums
+      )
+    );
+    return decodedArray.length === 1 ? decodedArray[0] : decodedArray;
+  }
+}

package/dist/utils/calldata/parser/index.cjs

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAbiParser = createAbiParser;
+exports.getAbiVersion = getAbiVersion;
+exports.isNoConstructorValid = isNoConstructorValid;
+var _cairo = require("../cairo.cjs");
+var _parser = require("./parser-0-1.1.0.cjs");
+var _parser2 = require("./parser-2.0.0.cjs");
+function createAbiParser(abi) {
+  const version = getAbiVersion(abi);
+  if (version === 0 || version === 1) {
+    return new _parser.AbiParser1(abi);
+  }
+  if (version === 2) {
+    return new _parser2.AbiParser2(abi);
+  }
+  throw Error(`Unsupported ABI version ${version}`);
+}
+function getAbiVersion(abi) {
+  if (abi.find(it => it.type === "interface")) return 2;
+  if ((0, _cairo.isCairo1Abi)(abi)) return 1;
+  return 0;
+}
+function isNoConstructorValid(method, argsCalldata, abiMethod) {
+  return method === "constructor" && !abiMethod && !argsCalldata.length;
+}

package/dist/utils/calldata/parser/index.d.ts

@@ -0,0 +1,5 @@
+import { Abi, FunctionAbi, RawArgs } from '../../../types';
+import { AbiParserInterface } from './interface';
+export declare function createAbiParser(abi: Abi): AbiParserInterface;
+export declare function getAbiVersion(abi: Abi): 1 | 0 | 2;
+export declare function isNoConstructorValid(method: string, argsCalldata: RawArgs, abiMethod?: FunctionAbi): boolean;