starknet 8.1.1 → 8.2.0

package/dist/index.global.js

@@ -21,19 +21,33 @@ var starknet = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    AbiParser1: () => AbiParser1,
+    AbiParser2: () => AbiParser2,
+    AbiParserInterface: () => AbiParserInterface,
     Account: () => Account,
     AccountInterface: () => AccountInterface,
     BatchClient: () => BatchClient,
     BlockStatus: () => BlockStatus,
     BlockTag: () => BlockTag,
+    CairoByteArray: () => CairoByteArray,
     CairoCustomEnum: () => CairoCustomEnum,
     CairoFixedArray: () => CairoFixedArray,
+    CairoInt128: () => CairoInt128,
+    CairoInt16: () => CairoInt16,
+    CairoInt32: () => CairoInt32,
+    CairoInt64: () => CairoInt64,
+    CairoInt8: () => CairoInt8,
     CairoOption: () => CairoOption,
     CairoOptionVariant: () => CairoOptionVariant,
     CairoResult: () => CairoResult,
     CairoResultVariant: () => CairoResultVariant,
+    CairoUint128: () => CairoUint128,
+    CairoUint16: () => CairoUint16,
     CairoUint256: () => CairoUint256,
     CairoUint512: () => CairoUint512,
+    CairoUint64: () => CairoUint64,
+    CairoUint8: () => CairoUint8,
+    CairoUint96: () => CairoUint96,
     CallData: () => CallData,
     Contract: () => Contract,
     ContractInterface: () => ContractInterface,
@@ -49,6 +63,7 @@ var starknet = (() => {
     ETransactionVersion3: () => ETransactionVersion33,
     EntryPointType: () => EntryPointType,
     EthSigner: () => EthSigner,
+    Int: () => Int,
     LedgerSigner: () => LedgerSigner111,
     LedgerSigner111: () => LedgerSigner111,
     LedgerSigner221: () => LedgerSigner221,
@@ -102,6 +117,8 @@ var starknet = (() => {
     config: () => config,
     constants: () => constants_exports,
     contractClassResponseToLegacyCompiledContract: () => contractClassResponseToLegacyCompiledContract,
+    createAbiParser: () => createAbiParser,
+    createTransactionReceipt: () => createTransactionReceipt,
     defaultDeployer: () => defaultDeployer,
     defaultPaymaster: () => defaultPaymaster,
     defaultProvider: () => defaultProvider,
@@ -110,6 +127,8 @@ var starknet = (() => {
     eth: () => eth_exports,
     events: () => events_exports,
     extractContractHashes: () => extractContractHashes,
+    fastParsingStrategy: () => fastParsingStrategy,
+    getAbiVersion: () => getAbiVersion,
     getChecksumAddress: () => getChecksumAddress,
     getGasPrices: () => getGasPrices,
     getLedgerPathBuffer: () => getLedgerPathBuffer111,
@@ -117,7 +136,9 @@ var starknet = (() => {
     getLedgerPathBuffer221: () => getLedgerPathBuffer221,
     getTipStatsFromBlocks: () => getTipStatsFromBlocks,
     hash: () => hash_exports,
+    hdParsingStrategy: () => hdParsingStrategy,
     isAccount: () => isAccount,
+    isNoConstructorValid: () => isNoConstructorValid,
     isPendingBlock: () => isPendingBlock,
     isPendingStateUpdate: () => isPendingStateUpdate,
     isPendingTransaction: () => isPendingTransaction,
@@ -175,7 +196,16 @@ var starknet = (() => {
     PRIME: () => PRIME,
     RANGE_FELT: () => RANGE_FELT,
     RANGE_I128: () => RANGE_I128,
+    RANGE_I16: () => RANGE_I16,
+    RANGE_I32: () => RANGE_I32,
+    RANGE_I64: () => RANGE_I64,
+    RANGE_I8: () => RANGE_I8,
     RANGE_U128: () => RANGE_U128,
+    RANGE_U16: () => RANGE_U16,
+    RANGE_U32: () => RANGE_U32,
+    RANGE_U64: () => RANGE_U64,
+    RANGE_U8: () => RANGE_U8,
+    RANGE_U96: () => RANGE_U96,
     RPC_DEFAULT_NODES: () => RPC_DEFAULT_NODES,
     SNIP9_V1_INTERFACE_ID: () => SNIP9_V1_INTERFACE_ID,
     SNIP9_V2_INTERFACE_ID: () => SNIP9_V2_INTERFACE_ID,
@@ -717,16 +747,22 @@ var starknet = (() => {
     addHexPrefix: () => addHexPrefix,
     arrayBufferToString: () => arrayBufferToString,
     atobUniversal: () => atobUniversal,
+    bigIntToUint8Array: () => bigIntToUint8Array,
     btoaUniversal: () => btoaUniversal,
     buf2hex: () => buf2hex,
     calcByteLength: () => calcByteLength,
     concatenateArrayBuffer: () => concatenateArrayBuffer,
+    hexStringToUint8Array: () => hexStringToUint8Array,
     padLeft: () => padLeft,
     pascalToSnake: () => pascalToSnake,
     removeHexPrefix: () => removeHexPrefix,
     sanitizeBytes: () => sanitizeBytes,
     sanitizeHex: () => sanitizeHex,
-    utf8ToArray: () => utf8ToArray
+    stringToUint8Array: () => stringToUint8Array,
+    uint8ArrayToBigInt: () => uint8ArrayToBigInt,
+    utf8ToArray: () => utf8ToArray,
+    utf8ToBigInt: () => utf8ToBigInt,
+    utf8ToUint8Array: () => utf8ToUint8Array
   });
 
   // node_modules/@scure/base/lib/esm/index.js
@@ -913,9 +949,13 @@ var starknet = (() => {
   function arrayBufferToString(array) {
     return new Uint8Array(array).reduce((data, byte) => data + String.fromCharCode(byte), "");
   }
-  function utf8ToArray(str) {
+  function utf8ToUint8Array(str) {
     return new TextEncoder().encode(str);
   }
+  var utf8ToArray = utf8ToUint8Array;
+  function utf8ToBigInt(str) {
+    return uint8ArrayToBigInt(utf8ToUint8Array(str));
+  }
   function atobUniversal(a) {
     return base64.decode(a);
   }
@@ -967,6 +1007,61 @@ var starknet = (() => {
     });
     return result;
   }
+  function hexStringToUint8Array(hex) {
+    const cleanHex2 = hex.startsWith("0x") ? hex.slice(2) : hex;
+    if (cleanHex2.length > 0 && !/^[0-9a-fA-F]+$/.test(cleanHex2)) {
+      throw new Error(`Invalid hex string: "${hex}" contains non-hexadecimal characters`);
+    }
+    const paddedHex = cleanHex2.length % 2 !== 0 ? `0${cleanHex2}` : cleanHex2;
+    const bytes = new Uint8Array(paddedHex.length / 2);
+    for (let i = 0; i < paddedHex.length; i += 2) {
+      bytes[i / 2] = parseInt(paddedHex.substring(i, i + 2), 16);
+    }
+    return bytes;
+  }
+  function isHexString(hex) {
+    return /^0[xX][0-9a-fA-F]*$/.test(hex);
+  }
+  function isDecimalString(str) {
+    return /^[0-9]+$/.test(str);
+  }
+  function stringToUint8Array(str) {
+    if (isHexString(str)) {
+      return hexStringToUint8Array(str);
+    }
+    if (isDecimalString(str)) {
+      const value = BigInt(str);
+      return bigIntToUint8Array(value);
+    }
+    return utf8ToUint8Array(str);
+  }
+  function bigIntToUint8Array(value) {
+    if (value < 0n) {
+      throw new Error(`Cannot convert negative bigint ${value} to Uint8Array`);
+    }
+    if (value === 0n) {
+      return new Uint8Array([0]);
+    }
+    let hex = value.toString(16);
+    if (hex.length % 2 !== 0) {
+      hex = `0${hex}`;
+    }
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+      bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    }
+    return bytes;
+  }
+  function uint8ArrayToBigInt(data) {
+    if (!data || data.length === 0) {
+      return 0n;
+    }
+    let hex = "0x";
+    for (let i = 0; i < data.length; i += 1) {
+      hex += data[i].toString(16).padStart(2, "0");
+    }
+    return BigInt(hex);
+  }
 
   // src/global/constants.ts
   var TEXT_TO_FELT_MAX_LEN = 31;
@@ -979,8 +1074,17 @@ var starknet = (() => {
   var ADDR_BOUND = 2n ** 251n - MAX_STORAGE_ITEM_SIZE;
   var range = (min, max) => ({ min, max });
   var RANGE_FELT = range(ZERO, PRIME - 1n);
-  var RANGE_I128 = range(-(2n ** 127n), 2n ** 127n - 1n);
+  var RANGE_U8 = range(ZERO, 2n ** 8n - 1n);
+  var RANGE_U16 = range(ZERO, 2n ** 16n - 1n);
+  var RANGE_U32 = range(ZERO, 2n ** 32n - 1n);
+  var RANGE_U64 = range(ZERO, 2n ** 64n - 1n);
+  var RANGE_U96 = range(ZERO, 2n ** 96n - 1n);
   var RANGE_U128 = range(ZERO, 2n ** 128n - 1n);
+  var RANGE_I8 = range(-(2n ** 7n), 2n ** 7n - 1n);
+  var RANGE_I16 = range(-(2n ** 15n), 2n ** 15n - 1n);
+  var RANGE_I32 = range(-(2n ** 31n), 2n ** 31n - 1n);
+  var RANGE_I64 = range(-(2n ** 63n), 2n ** 63n - 1n);
+  var RANGE_I128 = range(-(2n ** 127n), 2n ** 127n - 1n);
   var LegacyUDC = {
     ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf",
     ENTRYPOINT: "deployContract"
@@ -1047,7 +1151,8 @@ var starknet = (() => {
     },
     defaultTipType: "recommendedTip",
     fetch: void 0,
-    websocket: void 0
+    websocket: void 0,
+    buffer: void 0
   };
   var RPC_DEFAULT_NODES = {
     SN_MAIN: [`https://starknet-mainnet.public.blastapi.io/rpc/`],
@@ -1065,7 +1170,10 @@ var starknet = (() => {
     unsupportedSpecVersion: "The connected node specification version is not supported by this library",
     maxFeeInV3: "maxFee is not supported in V3 transactions, use resourceBounds instead",
     declareNonSierra: "Declaring non Sierra (Cairo0)contract using RPC 0.8+",
-    unsupportedMethodForRpcVersion: "Unsupported method for RPC version"
+    unsupportedMethodForRpcVersion: "Unsupported method for RPC version",
+    txEvictedFromMempool: "Transaction TTL, evicted from the mempool, try to increase the tip",
+    consensusFailed: "Consensus failed to finalize the block proposal",
+    txFailsBlockBuildingValidation: "Transaction fails block building validation"
   };
 
   // src/global/config.ts
@@ -1288,12 +1396,20 @@ ${JSON.stringify(data, null, 2)}`;
     u16: "core::integer::u16",
     u32: "core::integer::u32",
     u64: "core::integer::u64",
+    u96: "core::integer::u96",
     u128: "core::integer::u128",
     u256: "core::integer::u256",
     // This one is struct
     u512: "core::integer::u512"
     // This one is struct
   };
+  var Int = {
+    i8: "core::integer::i8",
+    i16: "core::integer::i16",
+    i32: "core::integer::i32",
+    i64: "core::integer::i64",
+    i128: "core::integer::i128"
+  };
   var Literal = {
     ClassHash: "core::starknet::class_hash::ClassHash",
     ContractAddress: "core::starknet::contract_address::ContractAddress",
@@ -2052,10 +2168,12 @@ ${indent}}` : "}";
     getDecimalString: () => getDecimalString,
     getHexString: () => getHexString,
     getHexStringArray: () => getHexStringArray,
+    getNext: () => getNext,
     hexToBytes: () => hexToBytes2,
     hexToDecimalString: () => hexToDecimalString,
     isBigNumberish: () => isBigNumberish,
     isHex: () => isHex2,
+    isHexString: () => isHexString2,
     isStringWholeNumber: () => isStringWholeNumber,
     stringToSha256ToArrayBuff4: () => stringToSha256ToArrayBuff4,
     toBigInt: () => toBigInt,
@@ -2709,14 +2827,21 @@ ${indent}}` : "}";
   function isString(value) {
     return typeof value === "string";
   }
+  function isBuffer(obj) {
+    return typeof Buffer !== "undefined" && obj instanceof Buffer;
+  }
   function isObject2(item) {
     return !!item && typeof item === "object" && !Array.isArray(item);
   }
+  function isInteger2(value) {
+    return Number.isInteger(value);
+  }
 
   // src/utils/num.ts
   function isHex2(hex) {
     return /^0[xX][0-9a-fA-F]*$/.test(hex);
   }
+  var isHexString2 = isHex2;
   function toBigInt(value) {
     return BigInt(value);
   }
@@ -2804,6 +2929,11 @@ ${indent}}` : "}";
   function isBigNumberish(input) {
     return isNumber2(input) || isBigInt(input) || isString(input) && (isHex2(input) || isStringWholeNumber(input));
   }
+  function getNext(iterator) {
+    const it = iterator.next();
+    if (it.done) throw new Error("Unexpected end of response");
+    return it.value;
+  }
 
   // src/utils/hash/selector.ts
   var selector_exports = {};
@@ -5051,7 +5181,7 @@ ${indent}}` : "}";
     decodeShortString: () => decodeShortString,
     encodeShortString: () => encodeShortString,
     isASCII: () => isASCII,
-    isDecimalString: () => isDecimalString,
+    isDecimalString: () => isDecimalString2,
     isLongText: () => isLongText,
     isShortString: () => isShortString,
     isShortText: () => isShortText,
@@ -5064,7 +5194,7 @@ ${indent}}` : "}";
   function isShortString(str) {
     return str.length <= TEXT_TO_FELT_MAX_LEN;
   }
-  function isDecimalString(str) {
+  function isDecimalString2(str) {
     return /^[0-9]*$/i.test(str);
   }
   function isText(val) {
@@ -5086,7 +5216,7 @@ ${indent}}` : "}";
     if (isHex2(str)) {
       return removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
     }
-    if (isDecimalString(str)) {
+    if (isDecimalString2(str)) {
       return decodeShortString("0X".concat(BigInt(str).toString(16)));
     }
     throw new Error(`${str} is not Hex or decimal`);
@@ -5128,12 +5258,11 @@ ${indent}}` : "}";
     isLen: () => isLen,
     isTypeArray: () => isTypeArray,
     isTypeBool: () => isTypeBool,
-    isTypeByteArray: () => isTypeByteArray,
-    isTypeBytes31: () => isTypeBytes31,
     isTypeContractAddress: () => isTypeContractAddress,
     isTypeEnum: () => isTypeEnum,
     isTypeEthAddress: () => isTypeEthAddress,
     isTypeFelt: () => isTypeFelt,
+    isTypeInt: () => isTypeInt,
     isTypeLiteral: () => isTypeLiteral,
     isTypeNamedTuple: () => isTypeNamedTuple,
     isTypeNonZero: () => isTypeNonZero,
@@ -5150,6 +5279,16 @@ ${indent}}` : "}";
     uint512: () => uint512
   });
 
+  // src/utils/helpers.ts
+  function addCompiledFlag(compiled) {
+    Object.defineProperty(compiled, "__compiled__", {
+      enumerable: false,
+      writable: false,
+      value: true
+    });
+    return compiled;
+  }
+
   // src/utils/cairoDataTypes/felt.ts
   function CairoFelt(it) {
     if (isBigInt(it) || Number.isInteger(it)) {
@@ -5176,6 +5315,69 @@ ${indent}}` : "}";
     }
     throw new Error(`${it} can't be computed by felt()`);
   }
+  var CairoFelt252 = class _CairoFelt252 {
+    /**
+     * byte representation of the felt252
+     */
+    data;
+    static abiSelector = "core::felt252";
+    constructor(data) {
+      _CairoFelt252.validate(data);
+      this.data = _CairoFelt252.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data)) {
+        return stringToUint8Array(data);
+      }
+      if (isBigInt(data)) {
+        return bigIntToUint8Array(data);
+      }
+      if (Number.isInteger(data)) {
+        return bigIntToUint8Array(BigInt(data));
+      }
+      if (isBoolean(data)) {
+        return bigIntToUint8Array(BigInt(data ? 1 : 0));
+      }
+      throw new Error(`${data} can't be computed by felt()`);
+    }
+    toBigInt() {
+      return uint8ArrayToBigInt(this.data);
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(this.data);
+    }
+    toHexString() {
+      return addHexPrefix(this.toBigInt().toString(16));
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    static validate(data) {
+      assert(data !== null, "null value is not allowed for felt252");
+      assert(data !== void 0, "undefined value is not allowed for felt252");
+      assert(
+        isString(data) || isNumber2(data) || isBigInt(data) || isBoolean(data),
+        `Unsupported data type '${typeof data}' for felt252. Expected string, number, bigint, or boolean`
+      );
+      const value = _CairoFelt252.__processData(data);
+      const bn = uint8ArrayToBigInt(value);
+      assert(bn >= 0n && bn < PRIME, `Value ${value} is out of felt252 range [0, ${PRIME})`);
+    }
+    static is(data) {
+      try {
+        _CairoFelt252.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    static isAbiType(abiType) {
+      return abiType === _CairoFelt252.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      return new _CairoFelt252(getNext(responseIterator));
+    }
+  };
 
   // src/utils/cairoDataTypes/uint256.ts
   var UINT_128_MAX = (1n << 128n) - 1n;
@@ -5187,11 +5389,16 @@ ${indent}}` : "}";
   var UINT_256_HIGH_MIN = 0n;
   var CairoUint256 = class _CairoUint256 {
     low;
+    // TODO should be u128
     high;
+    // TODO should be u128
     static abiSelector = "core::integer::u256";
     constructor(...arr) {
       if (isObject2(arr[0]) && arr.length === 1 && "low" in arr[0] && "high" in arr[0]) {
-        const props = _CairoUint256.validateProps(arr[0].low, arr[0].high);
+        const props = _CairoUint256.validateProps(
+          arr[0].low,
+          arr[0].high
+        );
         this.low = props.low;
         this.high = props.high;
       } else if (arr.length === 1) {
@@ -5210,9 +5417,15 @@ ${indent}}` : "}";
      * Validate if BigNumberish can be represented as Unit256
      */
     static validate(bigNumberish) {
+      assert(bigNumberish !== null, "null value is not allowed for u256");
+      assert(bigNumberish !== void 0, "undefined value is not allowed for u256");
+      assert(
+        isBigNumberish(bigNumberish) || isObject2(bigNumberish),
+        `Unsupported data type '${typeof bigNumberish}' for u256. Expected string, number, bigint, or Uint256 object`
+      );
       const bigInt = BigInt(bigNumberish);
-      if (bigInt < UINT_256_MIN) throw Error("bigNumberish is smaller than UINT_256_MIN");
-      if (bigInt > UINT_256_MAX) throw new Error("bigNumberish is bigger than UINT_256_MAX");
+      assert(bigInt >= UINT_256_MIN, "bigNumberish is smaller than UINT_256_MIN");
+      assert(bigInt <= UINT_256_MAX, "bigNumberish is bigger than UINT_256_MAX");
       return bigInt;
     }
     /**
@@ -5221,12 +5434,14 @@ ${indent}}` : "}";
     static validateProps(low, high) {
       const bigIntLow = BigInt(low);
       const bigIntHigh = BigInt(high);
-      if (bigIntLow < UINT_256_LOW_MIN || bigIntLow > UINT_256_LOW_MAX) {
-        throw new Error("low is out of range UINT_256_LOW_MIN - UINT_256_LOW_MAX");
-      }
-      if (bigIntHigh < UINT_256_HIGH_MIN || bigIntHigh > UINT_256_HIGH_MAX) {
-        throw new Error("high is out of range UINT_256_HIGH_MIN - UINT_256_HIGH_MAX");
-      }
+      assert(
+        bigIntLow >= UINT_256_LOW_MIN && bigIntLow <= UINT_256_LOW_MAX,
+        "low is out of range UINT_256_LOW_MIN - UINT_256_LOW_MAX"
+      );
+      assert(
+        bigIntHigh >= UINT_256_HIGH_MIN && bigIntHigh <= UINT_256_HIGH_MAX,
+        "high is out of range UINT_256_HIGH_MIN - UINT_256_HIGH_MAX"
+      );
       return { low: bigIntLow, high: bigIntHigh };
     }
     /**
@@ -5246,6 +5461,11 @@ ${indent}}` : "}";
     static isAbiType(abiType) {
       return abiType === _CairoUint256.abiSelector;
     }
+    static factoryFromApiResponse(responseIterator) {
+      const low = getNext(responseIterator);
+      const high = getNext(responseIterator);
+      return new _CairoUint256(low, high);
+    }
     /**
      * Return bigint representation
      */
@@ -5286,9 +5506,13 @@ ${indent}}` : "}";
   var UINT_128_MIN = 0n;
   var CairoUint512 = class _CairoUint512 {
     limb0;
+    // TODO should be u128
     limb1;
+    // TODO should be u128
     limb2;
+    // TODO should be u128
     limb3;
+    // TODO should be u128
     static abiSelector = "core::integer::u512";
     constructor(...arr) {
       if (isObject2(arr[0]) && arr.length === 1 && "limb0" in arr[0] && "limb1" in arr[0] && "limb2" in arr[0] && "limb3" in arr[0]) {
@@ -5322,9 +5546,15 @@ ${indent}}` : "}";
      * Validate if BigNumberish can be represented as Uint512
      */
     static validate(bigNumberish) {
+      assert(bigNumberish !== null, "null value is not allowed for u512");
+      assert(bigNumberish !== void 0, "undefined value is not allowed for u512");
+      assert(
+        isBigNumberish(bigNumberish) || isObject2(bigNumberish),
+        `Unsupported data type '${typeof bigNumberish}' for u512. Expected string, number, bigint, or Uint512 object`
+      );
       const bigInt = BigInt(bigNumberish);
-      if (bigInt < UINT_512_MIN) throw Error("bigNumberish is smaller than UINT_512_MIN.");
-      if (bigInt > UINT_512_MAX) throw Error("bigNumberish is bigger than UINT_512_MAX.");
+      assert(bigInt >= UINT_512_MIN, "bigNumberish is smaller than UINT_512_MIN.");
+      assert(bigInt <= UINT_512_MAX, "bigNumberish is bigger than UINT_512_MAX.");
       return bigInt;
     }
     /**
@@ -5336,9 +5566,10 @@ ${indent}}` : "}";
       const l2 = BigInt(limb2);
       const l3 = BigInt(limb3);
       [l0, l1, l2, l3].forEach((value, index) => {
-        if (value < UINT_128_MIN || value > UINT_128_MAX) {
-          throw Error(`limb${index} is not in the range of a u128 number`);
-        }
+        assert(
+          value >= UINT_128_MIN && value <= UINT_128_MAX,
+          `limb${index} is not in the range of a u128 number`
+        );
       });
       return { limb0: l0, limb1: l1, limb2: l2, limb3: l3 };
     }
@@ -5359,6 +5590,13 @@ ${indent}}` : "}";
     static isAbiType(abiType) {
       return abiType === _CairoUint512.abiSelector;
     }
+    static factoryFromApiResponse(responseIterator) {
+      const limb0 = getNext(responseIterator);
+      const limb1 = getNext(responseIterator);
+      const limb2 = getNext(responseIterator);
+      const limb3 = getNext(responseIterator);
+      return new _CairoUint512(limb0, limb1, limb2, limb3);
+    }
     /**
      * Return bigint representation
      */
@@ -5413,13 +5651,12 @@ ${indent}}` : "}";
   var isTypeOption = (type) => type.startsWith("core::option::Option::");
   var isTypeResult = (type) => type.startsWith("core::result::Result::");
   var isTypeUint = (type) => Object.values(Uint).includes(type);
+  var isTypeInt = (type) => Object.values(Int).includes(type);
   var isTypeUint256 = (type) => CairoUint256.isAbiType(type);
   var isTypeLiteral = (type) => Object.values(Literal).includes(type);
   var isTypeBool = (type) => type === "core::bool";
   var isTypeContractAddress = (type) => type === Literal.ContractAddress;
   var isTypeEthAddress = (type) => type === ETH_ADDRESS;
-  var isTypeBytes31 = (type) => type === "core::bytes_31::bytes31";
-  var isTypeByteArray = (type) => type === "core::byte_array::ByteArray";
   var isTypeU96 = (type) => type === "core::internal::bounded_int::BoundedInt::<0, 79228162514264337593543950335>";
   var isTypeSecp256k1Point = (type) => type === Literal.Secp256k1Point;
   var isCairo1Type = (type) => type.includes("::");
@@ -5674,15 +5911,1348 @@ ${indent}}` : "}";
         guard.unknown(data, type, key);
         return acc;
       },
-      {}
-    );
-  }
+      {}
+    );
+  }
+
+  // src/utils/calldata/parser/interface.ts
+  var AbiParserInterface = class {
+  };
+
+  // src/utils/cairoDataTypes/bytes31.ts
+  var CairoBytes31 = class _CairoBytes31 {
+    static MAX_BYTE_SIZE = 31;
+    data;
+    static abiSelector = "core::bytes_31::bytes31";
+    constructor(data) {
+      _CairoBytes31.validate(data);
+      this.data = _CairoBytes31.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data)) {
+        return stringToUint8Array(data);
+      }
+      if (isBuffer(data)) {
+        return new Uint8Array(data);
+      }
+      if (data instanceof Uint8Array) {
+        return new Uint8Array(data);
+      }
+      throw new Error("Invalid input type for CairoBytes31. Expected string, Buffer, or Uint8Array");
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    toBigInt() {
+      return uint8ArrayToBigInt(this.data);
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(this.data);
+    }
+    toHexString() {
+      return addHexPrefix(this.toBigInt().toString(16));
+    }
+    static validate(data) {
+      const byteLength = _CairoBytes31.__processData(data).length;
+      assert(
+        byteLength <= this.MAX_BYTE_SIZE,
+        `Data is too long: ${byteLength} bytes (max ${this.MAX_BYTE_SIZE} bytes)`
+      );
+    }
+    static is(data) {
+      try {
+        _CairoBytes31.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoBytes31.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      return new _CairoBytes31(getNext(responseIterator));
+    }
+  };
+
+  // src/utils/errors/rpc.ts
+  var errorCodes = {
+    FAILED_TO_RECEIVE_TXN: 1,
+    NO_TRACE_AVAILABLE: 10,
+    CONTRACT_NOT_FOUND: 20,
+    ENTRYPOINT_NOT_FOUND: 21,
+    BLOCK_NOT_FOUND: 24,
+    INVALID_TXN_INDEX: 27,
+    CLASS_HASH_NOT_FOUND: 28,
+    TXN_HASH_NOT_FOUND: 29,
+    PAGE_SIZE_TOO_BIG: 31,
+    NO_BLOCKS: 32,
+    INVALID_CONTINUATION_TOKEN: 33,
+    TOO_MANY_KEYS_IN_FILTER: 34,
+    CONTRACT_ERROR: 40,
+    TRANSACTION_EXECUTION_ERROR: 41,
+    STORAGE_PROOF_NOT_SUPPORTED: 42,
+    CLASS_ALREADY_DECLARED: 51,
+    INVALID_TRANSACTION_NONCE: 52,
+    INSUFFICIENT_RESOURCES_FOR_VALIDATE: 53,
+    INSUFFICIENT_ACCOUNT_BALANCE: 54,
+    VALIDATION_FAILURE: 55,
+    COMPILATION_FAILED: 56,
+    CONTRACT_CLASS_SIZE_IS_TOO_LARGE: 57,
+    NON_ACCOUNT: 58,
+    DUPLICATE_TX: 59,
+    COMPILED_CLASS_HASH_MISMATCH: 60,
+    UNSUPPORTED_TX_VERSION: 61,
+    UNSUPPORTED_CONTRACT_CLASS_VERSION: 62,
+    UNEXPECTED_ERROR: 63,
+    INVALID_SUBSCRIPTION_ID: 66,
+    TOO_MANY_ADDRESSES_IN_FILTER: 67,
+    TOO_MANY_BLOCKS_BACK: 68,
+    COMPILATION_ERROR: 100,
+    INVALID_ADDRESS: 150,
+    TOKEN_NOT_SUPPORTED: 151,
+    INVALID_SIGNATURE: 153,
+    MAX_AMOUNT_TOO_LOW: 154,
+    CLASS_HASH_NOT_SUPPORTED: 155,
+    PAYMASTER_TRANSACTION_EXECUTION_ERROR: 156,
+    INVALID_TIME_BOUNDS: 157,
+    INVALID_DEPLOYMENT_DATA: 158,
+    INVALID_CLASS_HASH: 159,
+    INVALID_ID: 160,
+    UNKNOWN_ERROR: 163
+  };
+  var rpc_default = errorCodes;
+
+  // src/utils/errors/index.ts
+  function fixStack(target, fn = target.constructor) {
+    const { captureStackTrace } = Error;
+    captureStackTrace && captureStackTrace(target, fn);
+  }
+  function fixProto(target, prototype) {
+    const { setPrototypeOf } = Object;
+    setPrototypeOf ? setPrototypeOf(target, prototype) : target.__proto__ = prototype;
+  }
+  var CustomError = class extends Error {
+    name;
+    constructor(message) {
+      super(message);
+      Object.defineProperty(this, "name", {
+        value: new.target.name,
+        enumerable: false,
+        configurable: true
+      });
+      fixProto(this, new.target.prototype);
+      fixStack(this);
+    }
+  };
+  var LibraryError = class extends CustomError {
+  };
+  var RpcError = class extends LibraryError {
+    constructor(baseError, method, params) {
+      super(`RPC: ${method} with params ${stringify2(params, null, 2)}
+
+      ${baseError.code}: ${baseError.message}: ${stringify2(baseError.data)}`);
+      this.baseError = baseError;
+      this.request = { method, params };
+    }
+    request;
+    get code() {
+      return this.baseError.code;
+    }
+    /**
+     * Verifies the underlying RPC error, also serves as a type guard for the _baseError_ property
+     * @example
+     * ```typescript
+     * SomeError.isType('UNEXPECTED_ERROR');
+     * ```
+     */
+    isType(typeName) {
+      return rpc_default[typeName] === this.code;
+    }
+  };
+  var TimeoutError = class extends LibraryError {
+    constructor(message) {
+      super(message);
+      this.name = "TimeoutError";
+    }
+  };
+  var WebSocketNotConnectedError = class extends LibraryError {
+    constructor(message) {
+      super(message);
+      this.name = "WebSocketNotConnectedError";
+    }
+  };
+
+  // src/utils/connect/buffer.ts
+  var buffer_default = config.get("buffer") || typeof Buffer !== "undefined" && Buffer || typeof globalThis !== "undefined" && globalThis.Buffer || typeof window !== "undefined" && window.Buffer || typeof global !== "undefined" && global.Buffer || class {
+    constructor() {
+      throw new LibraryError(
+        `Buffer not detected, use 'config.set("buffer", YourBufferPolyfill)' or polyfill or Node.js environment for Buffer support`
+      );
+    }
+    static from(_data) {
+      throw new LibraryError(
+        `Buffer not detected, use 'config.set("buffer", YourBufferPolyfill)' or polyfill or Node.js environment for Buffer support`
+      );
+    }
+    static isBuffer(obj) {
+      const BufferImpl = config.get("buffer") || typeof Buffer !== "undefined" && Buffer;
+      return BufferImpl && BufferImpl.isBuffer && BufferImpl.isBuffer(obj);
+    }
+  };
+
+  // src/utils/cairoDataTypes/uint32.ts
+  var CairoUint32 = class _CairoUint32 {
+    data;
+    static abiSelector = "core::u32::u32";
+    constructor(data) {
+      _CairoUint32.validate(data);
+      this.data = _CairoUint32.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data) && isText(data)) {
+        return utf8ToBigInt(data);
+      }
+      return BigInt(data);
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    toBigInt() {
+      return this.data;
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(bigIntToUint8Array(this.data));
+    }
+    toHexString() {
+      return addHexPrefix(this.toBigInt().toString(16));
+    }
+    static validate(data) {
+      assert(data !== null && data !== void 0, "Invalid input: null or undefined");
+      assert(!isObject2(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+      assert(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = _CairoUint32.__processData(data);
+      assert(value >= 0n && value <= 2n ** 32n - 1n, "Value is out of u32 range [0, 2^32)");
+    }
+    static is(data) {
+      try {
+        _CairoUint32.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoUint32.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      return new _CairoUint32(getNext(responseIterator));
+    }
+  };
+
+  // src/utils/cairoDataTypes/byteArray.ts
+  var CairoByteArray = class _CairoByteArray {
+    /**
+     * entire dataset
+     */
+    data = [];
+    /**
+     * cairo specific implementation helper
+     */
+    pending_word;
+    // felt
+    /**
+     * cairo specific implementation helper
+     */
+    pending_word_len;
+    // u32
+    static abiSelector = "core::byte_array::ByteArray";
+    constructor(...arr) {
+      if (arr.length === 3) {
+        const [dataArg, pendingWord, pendingWordLen] = arr;
+        assert(
+          Array.isArray(dataArg) && pendingWord instanceof CairoFelt252 && pendingWordLen instanceof CairoUint32,
+          "Invalid constructor parameters. Expected (CairoBytes31[], CairoFelt252, CairoUint32)"
+        );
+        this.data = dataArg;
+        this.pending_word = pendingWord;
+        this.pending_word_len = pendingWordLen;
+        return;
+      }
+      const inData = arr[0];
+      _CairoByteArray.validate(inData);
+      const { data, pending_word, pending_word_len } = _CairoByteArray.__processData(inData);
+      this.data = data;
+      this.pending_word = pending_word;
+      this.pending_word_len = pending_word_len;
+    }
+    static __processData(inData) {
+      let fullData;
+      if (inData instanceof Uint8Array) {
+        fullData = inData;
+      } else if (isBuffer(inData)) {
+        fullData = new Uint8Array(inData);
+      } else if (isString(inData)) {
+        fullData = stringToUint8Array(inData);
+      } else if (isBigInt(inData)) {
+        fullData = bigIntToUint8Array(inData);
+      } else if (isInteger2(inData)) {
+        fullData = bigIntToUint8Array(BigInt(inData));
+      } else {
+        throw new Error("Invalid input type. Expected Uint8Array, Buffer, string, number, or bigint");
+      }
+      const CHUNK_SIZE = CairoBytes31.MAX_BYTE_SIZE;
+      const completeChunks = Math.floor(fullData.length / CHUNK_SIZE);
+      const remainderLength = fullData.length % CHUNK_SIZE;
+      const data = [];
+      let pending_word;
+      let pending_word_len;
+      for (let i = 0; i < completeChunks; i += 1) {
+        const chunkStart = i * CHUNK_SIZE;
+        const chunkEnd = chunkStart + CHUNK_SIZE;
+        const chunk = fullData.slice(chunkStart, chunkEnd);
+        data.push(new CairoBytes31(chunk));
+      }
+      if (remainderLength > 0) {
+        const remainder = fullData.slice(completeChunks * CHUNK_SIZE);
+        let hex = "0x";
+        for (let i = 0; i < remainder.length; i += 1) {
+          hex += remainder[i].toString(16).padStart(2, "0");
+        }
+        pending_word = new CairoFelt252(hex);
+        pending_word_len = new CairoUint32(remainderLength);
+      } else {
+        pending_word = new CairoFelt252(0);
+        pending_word_len = new CairoUint32(0);
+      }
+      return { data, pending_word, pending_word_len };
+    }
+    toApiRequest() {
+      this.assertInitialized();
+      return addCompiledFlag([
+        addHexPrefix(this.data.length.toString(16)),
+        ...this.data.flatMap((bytes31) => bytes31.toApiRequest()),
+        ...this.pending_word.toApiRequest(),
+        ...this.pending_word_len.toApiRequest()
+      ]);
+    }
+    decodeUtf8() {
+      const allBytes = this.reconstructBytes();
+      const fullBytes = new Uint8Array(allBytes);
+      return new TextDecoder().decode(fullBytes);
+    }
+    toBigInt() {
+      const allBytes = this.reconstructBytes();
+      if (allBytes.length === 0) {
+        return 0n;
+      }
+      let result = 0n;
+      allBytes.forEach((byte) => {
+        result = result * 256n + BigInt(byte);
+      });
+      return result;
+    }
+    toHexString() {
+      return addHexPrefix(this.toBigInt().toString(16));
+    }
+    toBuffer() {
+      this.assertInitialized();
+      const allBytes = [];
+      this.data.forEach((chunk) => {
+        const chunkBytes = chunk.data;
+        for (let i = 0; i < chunkBytes.length; i += 1) {
+          allBytes.push(chunkBytes[i]);
+        }
+      });
+      const pendingLen = Number(this.pending_word_len.toBigInt());
+      if (pendingLen > 0) {
+        const hex = this.pending_word.toHexString();
+        const hexWithoutPrefix = hex.startsWith("0x") ? hex.slice(2) : hex;
+        const paddedHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
+        for (let i = 0; i < pendingLen; i += 1) {
+          const byteHex = paddedHex.slice(i * 2, i * 2 + 2);
+          if (byteHex.length >= 2) {
+            const byteValue = parseInt(byteHex, 16);
+            if (!Number.isNaN(byteValue)) {
+              allBytes.push(byteValue);
+            }
+          }
+        }
+      }
+      return buffer_default.from(allBytes);
+    }
+    static validate(data) {
+      assert(data !== null && data !== void 0, "Invalid input: null or undefined");
+      assert(
+        !Array.isArray(data) || data instanceof Uint8Array,
+        "Invalid input: arrays are not supported, use Uint8Array"
+      );
+      assert(
+        typeof data !== "object" || isBuffer(data) || data instanceof Uint8Array,
+        "Invalid input for CairoByteArray: objects are not supported"
+      );
+      assert(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input for CairoByteArray: decimal numbers are not supported, only integers"
+      );
+      assert(
+        !isNumber2(data) || data >= 0,
+        "Invalid input for CairoByteArray: negative numbers are not supported"
+      );
+      assert(
+        !isBigInt(data) || data >= 0n,
+        "Invalid input for CairoByteArray: negative bigints are not supported"
+      );
+      assert(
+        data instanceof Uint8Array || isBuffer(data) || isString(data) || isNumber2(data) || isBigInt(data),
+        "Invalid input type. Expected Uint8Array, Buffer, string, number, or bigint"
+      );
+    }
+    /**
+     * Check if the provided data is a valid CairoByteArray
+     *
+     * @param data - The data to check
+     * @returns True if the data is a valid CairoByteArray, false otherwise
+     */
+    static is(data) {
+      try {
+        _CairoByteArray.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoByteArray.abiSelector;
+    }
+    /**
+     * Private helper to check if the CairoByteArray is properly initialized
+     */
+    assertInitialized() {
+      assert(
+        this.data && this.pending_word !== void 0 && this.pending_word_len !== void 0,
+        "CairoByteArray is not properly initialized"
+      );
+    }
+    /**
+     * Private helper to reconstruct the full byte sequence from chunks and pending word
+     */
+    reconstructBytes() {
+      this.assertInitialized();
+      const allBytes = [];
+      this.data.forEach((chunk) => {
+        const chunkBytes = chunk.data;
+        for (let i = 0; i < chunkBytes.length; i += 1) {
+          allBytes.push(chunkBytes[i]);
+        }
+      });
+      const pendingLen = Number(this.pending_word_len.toBigInt());
+      if (pendingLen > 0) {
+        const hex = this.pending_word.toHexString();
+        const hexWithoutPrefix = hex.startsWith("0x") ? hex.slice(2) : hex;
+        const paddedHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
+        for (let i = 0; i < pendingLen; i += 1) {
+          const byteHex = paddedHex.slice(i * 2, i * 2 + 2);
+          if (byteHex.length < 2) {
+            allBytes.push(0);
+          } else {
+            const byteValue = parseInt(byteHex, 16);
+            if (Number.isNaN(byteValue)) {
+              throw new Error(`Invalid hex byte: ${byteHex}`);
+            }
+            allBytes.push(byteValue);
+          }
+        }
+      }
+      return allBytes;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      const data = Array.from(
+        { length: Number(getNext(responseIterator)) },
+        () => CairoBytes31.factoryFromApiResponse(responseIterator)
+      );
+      const pending_word = CairoFelt252.factoryFromApiResponse(responseIterator);
+      const pending_word_len = CairoUint32.factoryFromApiResponse(responseIterator);
+      return new _CairoByteArray(data, pending_word, pending_word_len);
+    }
+  };
+
+  // src/utils/cairoDataTypes/uint8.ts
+  var CairoUint8 = class _CairoUint8 {
+    data;
+    static abiSelector = "core::integer::u8";
+    constructor(data) {
+      _CairoUint8.validate(data);
+      this.data = _CairoUint8.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data) && isText(data)) {
+        return utf8ToBigInt(data);
+      }
+      return BigInt(data);
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    toBigInt() {
+      return this.data;
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(bigIntToUint8Array(this.data));
+    }
+    toHexString() {
+      return addHexPrefix(this.toBigInt().toString(16));
+    }
+    static validate(data) {
+      assert(data !== null && data !== void 0, "Invalid input: null or undefined");
+      assert(!isObject2(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+      assert(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = _CairoUint8.__processData(data);
+      assert(
+        value >= RANGE_U8.min && value <= RANGE_U8.max,
+        `Value is out of u8 range [${RANGE_U8.min}, ${RANGE_U8.max}]`
+      );
+    }
+    static is(data) {
+      try {
+        _CairoUint8.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoUint8.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      return new _CairoUint8(getNext(responseIterator));
+    }
+  };
+
+  // src/utils/cairoDataTypes/uint16.ts
+  var CairoUint16 = class _CairoUint16 {
+    data;
+    static abiSelector = "core::integer::u16";
+    constructor(data) {
+      _CairoUint16.validate(data);
+      this.data = _CairoUint16.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data) && isText(data)) {
+        return utf8ToBigInt(data);
+      }
+      return BigInt(data);
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    toBigInt() {
+      return this.data;
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(bigIntToUint8Array(this.data));
+    }
+    toHexString() {
+      return addHexPrefix(this.toBigInt().toString(16));
+    }
+    static validate(data) {
+      assert(data !== null && data !== void 0, "Invalid input: null or undefined");
+      assert(!isObject2(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+      assert(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = _CairoUint16.__processData(data);
+      assert(
+        value >= RANGE_U16.min && value <= RANGE_U16.max,
+        `Value is out of u16 range [${RANGE_U16.min}, ${RANGE_U16.max}]`
+      );
+    }
+    static is(data) {
+      try {
+        _CairoUint16.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoUint16.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      return new _CairoUint16(getNext(responseIterator));
+    }
+  };
+
+  // src/utils/cairoDataTypes/uint64.ts
+  var CairoUint64 = class _CairoUint64 {
+    data;
+    static abiSelector = "core::integer::u64";
+    constructor(data) {
+      _CairoUint64.validate(data);
+      this.data = _CairoUint64.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data) && isText(data)) {
+        return utf8ToBigInt(data);
+      }
+      return BigInt(data);
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    toBigInt() {
+      return this.data;
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(bigIntToUint8Array(this.data));
+    }
+    toHexString() {
+      return addHexPrefix(this.toBigInt().toString(16));
+    }
+    static validate(data) {
+      assert(data !== null && data !== void 0, "Invalid input: null or undefined");
+      assert(!isObject2(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+      assert(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = _CairoUint64.__processData(data);
+      assert(
+        value >= RANGE_U64.min && value <= RANGE_U64.max,
+        `Value is out of u64 range [${RANGE_U64.min}, ${RANGE_U64.max}]`
+      );
+    }
+    static is(data) {
+      try {
+        _CairoUint64.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoUint64.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      return new _CairoUint64(getNext(responseIterator));
+    }
+  };
+
+  // src/utils/cairoDataTypes/uint96.ts
+  var CairoUint96 = class _CairoUint96 {
+    data;
+    static abiSelector = "core::integer::u96";
+    constructor(data) {
+      _CairoUint96.validate(data);
+      this.data = _CairoUint96.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data) && isText(data)) {
+        return utf8ToBigInt(data);
+      }
+      return BigInt(data);
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    toBigInt() {
+      return this.data;
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(bigIntToUint8Array(this.data));
+    }
+    toHexString() {
+      return addHexPrefix(this.toBigInt().toString(16));
+    }
+    static validate(data) {
+      assert(data !== null && data !== void 0, "Invalid input: null or undefined");
+      assert(!isObject2(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+      assert(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = _CairoUint96.__processData(data);
+      assert(
+        value >= RANGE_U96.min && value <= RANGE_U96.max,
+        `Value is out of u96 range [${RANGE_U96.min}, ${RANGE_U96.max}]`
+      );
+    }
+    static is(data) {
+      try {
+        _CairoUint96.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoUint96.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      return new _CairoUint96(getNext(responseIterator));
+    }
+  };
+
+  // src/utils/cairoDataTypes/uint128.ts
+  var CairoUint128 = class _CairoUint128 {
+    data;
+    static abiSelector = "core::integer::u128";
+    constructor(data) {
+      _CairoUint128.validate(data);
+      this.data = _CairoUint128.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data) && isText(data)) {
+        return utf8ToBigInt(data);
+      }
+      return BigInt(data);
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    toBigInt() {
+      return this.data;
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(bigIntToUint8Array(this.data));
+    }
+    toHexString() {
+      return addHexPrefix(this.toBigInt().toString(16));
+    }
+    static validate(data) {
+      assert(data !== null && data !== void 0, "Invalid input: null or undefined");
+      assert(!isObject2(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+      assert(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = _CairoUint128.__processData(data);
+      assert(
+        value >= RANGE_U128.min && value <= RANGE_U128.max,
+        `Value is out of u128 range [${RANGE_U128.min}, ${RANGE_U128.max}]`
+      );
+    }
+    static is(data) {
+      try {
+        _CairoUint128.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoUint128.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      return new _CairoUint128(getNext(responseIterator));
+    }
+  };
+
+  // src/utils/cairoDataTypes/int8.ts
+  var CairoInt8 = class _CairoInt8 {
+    data;
+    static abiSelector = "core::integer::i8";
+    constructor(data) {
+      _CairoInt8.validate(data);
+      this.data = _CairoInt8.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data) && isText(data)) {
+        return utf8ToBigInt(data);
+      }
+      return BigInt(data);
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    toBigInt() {
+      return this.data;
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(
+        bigIntToUint8Array(this.data >= 0n ? this.data : 256n + this.data)
+      );
+    }
+    /**
+     * For negative values field element representation as positive hex string.
+     * @returns cairo field arithmetic hex string
+     */
+    toHexString() {
+      const value = this.toBigInt();
+      if (value < 0n) {
+        const fieldElement = PRIME + value;
+        return addHexPrefix(fieldElement.toString(16));
+      }
+      return addHexPrefix(value.toString(16));
+    }
+    static validate(data) {
+      assert(data !== null && data !== void 0, "Invalid input: null or undefined");
+      assert(!isObject2(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+      assert(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = _CairoInt8.__processData(data);
+      assert(
+        value >= RANGE_I8.min && value <= RANGE_I8.max,
+        `Value is out of i8 range [${RANGE_I8.min}, ${RANGE_I8.max}]`
+      );
+    }
+    static is(data) {
+      try {
+        _CairoInt8.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoInt8.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      const response = getNext(responseIterator);
+      const value = BigInt(response);
+      const signedValue = value > PRIME / 2n ? value - PRIME : value;
+      return new _CairoInt8(signedValue);
+    }
+  };
+
+  // src/utils/cairoDataTypes/int16.ts
+  var CairoInt16 = class _CairoInt16 {
+    data;
+    static abiSelector = "core::integer::i16";
+    constructor(data) {
+      _CairoInt16.validate(data);
+      this.data = _CairoInt16.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data) && isText(data)) {
+        return utf8ToBigInt(data);
+      }
+      return BigInt(data);
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    toBigInt() {
+      return this.data;
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(
+        bigIntToUint8Array(this.data >= 0n ? this.data : 65536n + this.data)
+      );
+    }
+    /**
+     * For negative values field element representation as positive hex string.
+     * @returns cairo field arithmetic hex string
+     */
+    toHexString() {
+      const value = this.toBigInt();
+      if (value < 0n) {
+        const fieldElement = PRIME + value;
+        return addHexPrefix(fieldElement.toString(16));
+      }
+      return addHexPrefix(value.toString(16));
+    }
+    static validate(data) {
+      assert(data !== null && data !== void 0, "Invalid input: null or undefined");
+      assert(!isObject2(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+      assert(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = _CairoInt16.__processData(data);
+      assert(
+        value >= RANGE_I16.min && value <= RANGE_I16.max,
+        `Value is out of i16 range [${RANGE_I16.min}, ${RANGE_I16.max}]`
+      );
+    }
+    static is(data) {
+      try {
+        _CairoInt16.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoInt16.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      const response = getNext(responseIterator);
+      const value = BigInt(response);
+      const signedValue = value > PRIME / 2n ? value - PRIME : value;
+      return new _CairoInt16(signedValue);
+    }
+  };
+
+  // src/utils/cairoDataTypes/int32.ts
+  var CairoInt32 = class _CairoInt32 {
+    data;
+    static abiSelector = "core::integer::i32";
+    constructor(data) {
+      _CairoInt32.validate(data);
+      this.data = _CairoInt32.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data) && isText(data)) {
+        return utf8ToBigInt(data);
+      }
+      return BigInt(data);
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    toBigInt() {
+      return this.data;
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(
+        bigIntToUint8Array(this.data >= 0n ? this.data : 4294967296n + this.data)
+      );
+    }
+    /**
+     * For negative values field element representation as positive hex string.
+     * @returns cairo field arithmetic hex string
+     */
+    toHexString() {
+      const value = this.toBigInt();
+      if (value < 0n) {
+        const fieldElement = PRIME + value;
+        return addHexPrefix(fieldElement.toString(16));
+      }
+      return addHexPrefix(value.toString(16));
+    }
+    static validate(data) {
+      assert(data !== null && data !== void 0, "Invalid input: null or undefined");
+      assert(!isObject2(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+      assert(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = _CairoInt32.__processData(data);
+      assert(
+        value >= RANGE_I32.min && value <= RANGE_I32.max,
+        `Value is out of i32 range [${RANGE_I32.min}, ${RANGE_I32.max}]`
+      );
+    }
+    static is(data) {
+      try {
+        _CairoInt32.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoInt32.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      const response = getNext(responseIterator);
+      const value = BigInt(response);
+      const signedValue = value > PRIME / 2n ? value - PRIME : value;
+      return new _CairoInt32(signedValue);
+    }
+  };
+
+  // src/utils/cairoDataTypes/int64.ts
+  var CairoInt64 = class _CairoInt64 {
+    data;
+    static abiSelector = "core::integer::i64";
+    constructor(data) {
+      _CairoInt64.validate(data);
+      this.data = _CairoInt64.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data) && isText(data)) {
+        return utf8ToBigInt(data);
+      }
+      return BigInt(data);
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    toBigInt() {
+      return this.data;
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(
+        bigIntToUint8Array(this.data >= 0n ? this.data : 2n ** 64n + this.data)
+      );
+    }
+    /**
+     * For negative values field element representation as positive hex string.
+     * @returns cairo field arithmetic hex string
+     */
+    toHexString() {
+      const value = this.toBigInt();
+      if (value < 0n) {
+        const fieldElement = PRIME + value;
+        return addHexPrefix(fieldElement.toString(16));
+      }
+      return addHexPrefix(value.toString(16));
+    }
+    static validate(data) {
+      assert(data !== null && data !== void 0, "Invalid input: null or undefined");
+      assert(!isObject2(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+      assert(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = _CairoInt64.__processData(data);
+      assert(
+        value >= RANGE_I64.min && value <= RANGE_I64.max,
+        `Value is out of i64 range [${RANGE_I64.min}, ${RANGE_I64.max}]`
+      );
+    }
+    static is(data) {
+      try {
+        _CairoInt64.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoInt64.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      const response = getNext(responseIterator);
+      const value = BigInt(response);
+      const signedValue = value > PRIME / 2n ? value - PRIME : value;
+      return new _CairoInt64(signedValue);
+    }
+  };
+
+  // src/utils/cairoDataTypes/int128.ts
+  var CairoInt128 = class _CairoInt128 {
+    data;
+    static abiSelector = "core::integer::i128";
+    constructor(data) {
+      _CairoInt128.validate(data);
+      this.data = _CairoInt128.__processData(data);
+    }
+    static __processData(data) {
+      if (isString(data) && isText(data)) {
+        return utf8ToBigInt(data);
+      }
+      return BigInt(data);
+    }
+    toApiRequest() {
+      return addCompiledFlag([this.toHexString()]);
+    }
+    toBigInt() {
+      return this.data;
+    }
+    decodeUtf8() {
+      return new TextDecoder().decode(
+        bigIntToUint8Array(this.data >= 0n ? this.data : 2n ** 128n + this.data)
+      );
+    }
+    /**
+     * For negative values field element representation as positive hex string.
+     * @returns cairo field arithmetic hex string
+     */
+    toHexString() {
+      const value = this.toBigInt();
+      if (value < 0n) {
+        const fieldElement = PRIME + value;
+        return addHexPrefix(fieldElement.toString(16));
+      }
+      return addHexPrefix(value.toString(16));
+    }
+    static validate(data) {
+      assert(data !== null && data !== void 0, "Invalid input: null or undefined");
+      assert(!isObject2(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+      assert(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = _CairoInt128.__processData(data);
+      assert(
+        value >= RANGE_I128.min && value <= RANGE_I128.max,
+        `Value is out of i128 range [${RANGE_I128.min}, ${RANGE_I128.max}]`
+      );
+    }
+    static is(data) {
+      try {
+        _CairoInt128.validate(data);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoInt128.abiSelector;
+    }
+    static factoryFromApiResponse(responseIterator) {
+      const response = getNext(responseIterator);
+      const value = BigInt(response);
+      const signedValue = value > PRIME / 2n ? value - PRIME : value;
+      return new _CairoInt128(signedValue);
+    }
+  };
+
+  // src/utils/calldata/parser/parsingStrategy.ts
+  var hdParsingStrategy = {
+    // TODO: provjeri svi request parseri stvaraju array, dali je to ok sa requstParserom
+    request: {
+      [CairoBytes31.abiSelector]: (val) => {
+        return new CairoBytes31(val).toApiRequest();
+      },
+      [CairoByteArray.abiSelector]: (val) => {
+        return new CairoByteArray(val).toApiRequest();
+      },
+      [CairoFelt252.abiSelector]: (val) => {
+        return new CairoFelt252(val).toApiRequest();
+      },
+      [CairoUint256.abiSelector]: (val) => {
+        return new CairoUint256(val).toApiRequest();
+      },
+      [CairoUint512.abiSelector]: (val) => {
+        return new CairoUint512(val).toApiRequest();
+      },
+      [CairoUint8.abiSelector]: (val) => {
+        return new CairoUint8(val).toApiRequest();
+      },
+      [CairoUint16.abiSelector]: (val) => {
+        return new CairoUint16(val).toApiRequest();
+      },
+      [CairoUint64.abiSelector]: (val) => {
+        return new CairoUint64(val).toApiRequest();
+      },
+      [CairoUint96.abiSelector]: (val) => {
+        return new CairoUint96(val).toApiRequest();
+      },
+      [CairoUint128.abiSelector]: (val) => {
+        return new CairoUint128(val).toApiRequest();
+      },
+      [CairoInt8.abiSelector]: (val) => {
+        return new CairoInt8(val).toApiRequest();
+      },
+      [CairoInt16.abiSelector]: (val) => {
+        return new CairoInt16(val).toApiRequest();
+      },
+      [CairoInt32.abiSelector]: (val) => {
+        return new CairoInt32(val).toApiRequest();
+      },
+      [CairoInt64.abiSelector]: (val) => {
+        return new CairoInt64(val).toApiRequest();
+      },
+      [CairoInt128.abiSelector]: (val) => {
+        return new CairoInt128(val).toApiRequest();
+      }
+    },
+    response: {
+      [CairoBytes31.abiSelector]: (responseIterator) => {
+        return CairoBytes31.factoryFromApiResponse(responseIterator).decodeUtf8();
+      },
+      [CairoByteArray.abiSelector]: (responseIterator) => {
+        return CairoByteArray.factoryFromApiResponse(responseIterator).decodeUtf8();
+      },
+      [CairoFelt252.abiSelector]: (responseIterator) => {
+        return CairoFelt252.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoUint256.abiSelector]: (responseIterator) => {
+        return CairoUint256.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoUint512.abiSelector]: (responseIterator) => {
+        return CairoUint512.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoUint8.abiSelector]: (responseIterator) => {
+        return CairoUint8.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoUint16.abiSelector]: (responseIterator) => {
+        return CairoUint16.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoUint64.abiSelector]: (responseIterator) => {
+        return CairoUint64.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoUint96.abiSelector]: (responseIterator) => {
+        return CairoUint96.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoUint128.abiSelector]: (responseIterator) => {
+        return CairoUint128.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoInt8.abiSelector]: (responseIterator) => {
+        return CairoInt8.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoInt16.abiSelector]: (responseIterator) => {
+        return CairoInt16.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoInt32.abiSelector]: (responseIterator) => {
+        return CairoInt32.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoInt64.abiSelector]: (responseIterator) => {
+        return CairoInt64.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoInt128.abiSelector]: (responseIterator) => {
+        return CairoInt128.factoryFromApiResponse(responseIterator).toBigInt();
+      }
+    }
+  };
+  var fastParsingStrategy = {
+    request: {
+      [CairoBytes31.abiSelector]: (val) => {
+        return new CairoBytes31(val).toApiRequest();
+      },
+      [CairoByteArray.abiSelector]: (val) => {
+        return new CairoByteArray(val).toApiRequest();
+      },
+      [CairoFelt252.abiSelector]: (val) => {
+        return felt(val);
+      },
+      [CairoUint256.abiSelector]: (val) => {
+        return new CairoUint256(val).toApiRequest();
+      },
+      [CairoUint512.abiSelector]: (val) => {
+        return new CairoUint512(val).toApiRequest();
+      },
+      [CairoUint8.abiSelector]: (val) => {
+        return felt(val);
+      },
+      [CairoUint16.abiSelector]: (val) => {
+        return felt(val);
+      },
+      [CairoUint64.abiSelector]: (val) => {
+        return felt(val);
+      },
+      [CairoUint96.abiSelector]: (val) => {
+        return felt(val);
+      },
+      [CairoUint128.abiSelector]: (val) => {
+        return felt(val);
+      },
+      [CairoInt8.abiSelector]: (val) => {
+        return new CairoInt8(val).toApiRequest();
+      },
+      [CairoInt16.abiSelector]: (val) => {
+        return new CairoInt16(val).toApiRequest();
+      },
+      [CairoInt32.abiSelector]: (val) => {
+        return new CairoInt32(val).toApiRequest();
+      },
+      [CairoInt64.abiSelector]: (val) => {
+        return new CairoInt64(val).toApiRequest();
+      },
+      [CairoInt128.abiSelector]: (val) => {
+        return new CairoInt128(val).toApiRequest();
+      }
+    },
+    response: {
+      [CairoBytes31.abiSelector]: (responseIterator) => {
+        return CairoBytes31.factoryFromApiResponse(responseIterator).decodeUtf8();
+      },
+      [CairoByteArray.abiSelector]: (responseIterator) => {
+        return CairoByteArray.factoryFromApiResponse(responseIterator).decodeUtf8();
+      },
+      [CairoFelt252.abiSelector]: (responseIterator) => {
+        return BigInt(getNext(responseIterator));
+      },
+      [CairoUint256.abiSelector]: (responseIterator) => {
+        return CairoUint256.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoUint512.abiSelector]: (responseIterator) => {
+        return CairoUint512.factoryFromApiResponse(responseIterator).toBigInt();
+      },
+      [CairoUint8.abiSelector]: (responseIterator) => {
+        return BigInt(getNext(responseIterator));
+      },
+      [CairoUint16.abiSelector]: (responseIterator) => {
+        return BigInt(getNext(responseIterator));
+      },
+      [CairoUint64.abiSelector]: (responseIterator) => {
+        return BigInt(getNext(responseIterator));
+      },
+      [CairoUint96.abiSelector]: (responseIterator) => {
+        return BigInt(getNext(responseIterator));
+      },
+      [CairoUint128.abiSelector]: (responseIterator) => {
+        return BigInt(getNext(responseIterator));
+      },
+      [CairoInt8.abiSelector]: (responseIterator) => {
+        return BigInt(getNext(responseIterator));
+      },
+      [CairoInt16.abiSelector]: (responseIterator) => {
+        return BigInt(getNext(responseIterator));
+      },
+      [CairoInt32.abiSelector]: (responseIterator) => {
+        return BigInt(getNext(responseIterator));
+      },
+      [CairoInt64.abiSelector]: (responseIterator) => {
+        return BigInt(getNext(responseIterator));
+      },
+      [CairoInt128.abiSelector]: (responseIterator) => {
+        return BigInt(getNext(responseIterator));
+      }
+    }
+  };
 
   // src/utils/calldata/parser/parser-0-1.1.0.ts
   var AbiParser1 = class {
     abi;
-    constructor(abi) {
+    parsingStrategy;
+    constructor(abi, parsingStrategy) {
       this.abi = abi;
+      this.parsingStrategy = parsingStrategy || fastParsingStrategy;
+    }
+    getRequestParser(abiType) {
+      if (this.parsingStrategy.request[abiType]) {
+        return this.parsingStrategy.request[abiType];
+      }
+      throw new Error(`Parser for ${abiType} not found`);
+    }
+    getResponseParser(abiType) {
+      if (this.parsingStrategy.response[abiType]) {
+        return this.parsingStrategy.response[abiType];
+      }
+      throw new Error(`Parser for ${abiType} not found`);
     }
     /**
      * abi method inputs length without '_len' inputs
@@ -5713,8 +7283,22 @@ ${indent}}` : "}";
   // src/utils/calldata/parser/parser-2.0.0.ts
   var AbiParser2 = class {
     abi;
-    constructor(abi) {
+    parsingStrategy;
+    constructor(abi, parsingStrategy) {
       this.abi = abi;
+      this.parsingStrategy = parsingStrategy || fastParsingStrategy;
+    }
+    getRequestParser(abiType) {
+      if (this.parsingStrategy.request[abiType]) {
+        return this.parsingStrategy.request[abiType];
+      }
+      throw new Error(`Parser for ${abiType} not found`);
+    }
+    getResponseParser(abiType) {
+      if (this.parsingStrategy.response[abiType]) {
+        return this.parsingStrategy.response[abiType];
+      }
+      throw new Error(`Parser for ${abiType} not found`);
     }
     /**
      * abi method inputs length
@@ -5747,13 +7331,13 @@ ${indent}}` : "}";
   };
 
   // src/utils/calldata/parser/index.ts
-  function createAbiParser(abi) {
+  function createAbiParser(abi, parsingStrategy) {
     const version = getAbiVersion(abi);
     if (version === 0 || version === 1) {
-      return new AbiParser1(abi);
+      return new AbiParser1(abi, parsingStrategy);
     }
     if (version === 2) {
-      return new AbiParser2(abi);
+      return new AbiParser2(abi, parsingStrategy);
     }
     throw Error(`Unsupported ABI version ${version}`);
   }
@@ -5880,16 +7464,17 @@ ${indent}}` : "}";
           `The type ${arrayType} do not includes any content type. Needs [type; length].`
         );
       }
+      let arraySize;
       try {
-        _CairoFixedArray.getFixedArraySize(arrayType);
+        arraySize = _CairoFixedArray.getFixedArraySize(arrayType);
       } catch {
         throw new Error(
           `The type ${arrayType} type do not includes any length. Needs [type; length].`
         );
       }
       assert(
-        _CairoFixedArray.getFixedArraySize(arrayType) === content.length,
-        `The ABI type ${arrayType} is expecting ${_CairoFixedArray.getFixedArraySize(arrayType)} items. ${content.length} items provided.`
+        arraySize === content.length,
+        `The ABI type ${arrayType} is expecting ${arraySize} items. ${content.length} items provided.`
       );
       this.content = content;
       this.arrayType = arrayType;
@@ -5986,6 +7571,7 @@ ${indent}}` : "}";
     }
     /**
      * Checks if the given Cairo type is a fixed-array type.
+     * structure: [string; number]
      *
      * @param {string} type - The type to check.
      * @returns - `true` if the type is a fixed array type, `false` otherwise.
@@ -6030,7 +7616,7 @@ ${indent}}` : "}";
       if (isTypeNonZero(abiType)) {
         return unorderedItem;
       }
-      if (isTypeByteArray(abiType)) {
+      if (CairoByteArray.isAbiType(abiType)) {
         return unorderedItem;
       }
       if (isTypeU96(abiType)) {
@@ -6188,14 +7774,38 @@ ${indent}}` : "}";
   }
 
   // src/utils/calldata/requestParser.ts
-  function parseBaseTypes(type, val) {
+  function parseBaseTypes({
+    type,
+    val,
+    parser
+  }) {
     switch (true) {
       case CairoUint256.isAbiType(type):
-        return new CairoUint256(val).toApiRequest();
+        return parser.getRequestParser(type)(val);
       case CairoUint512.isAbiType(type):
-        return new CairoUint512(val).toApiRequest();
-      case isTypeBytes31(type):
-        return encodeShortString(val.toString());
+        return parser.getRequestParser(type)(val);
+      case CairoUint8.isAbiType(type):
+        return parser.getRequestParser(type)(val);
+      case CairoUint16.isAbiType(type):
+        return parser.getRequestParser(type)(val);
+      case CairoUint64.isAbiType(type):
+        return parser.getRequestParser(type)(val);
+      case CairoUint96.isAbiType(type):
+        return parser.getRequestParser(type)(val);
+      case CairoUint128.isAbiType(type):
+        return parser.getRequestParser(type)(val);
+      case CairoInt8.isAbiType(type):
+        return parser.getRequestParser(type)(val);
+      case CairoInt16.isAbiType(type):
+        return parser.getRequestParser(type)(val);
+      case CairoInt32.isAbiType(type):
+        return parser.getRequestParser(type)(val);
+      case CairoInt64.isAbiType(type):
+        return parser.getRequestParser(type)(val);
+      case CairoInt128.isAbiType(type):
+        return parser.getRequestParser(type)(val);
+      case CairoBytes31.isAbiType(type):
+        return parser.getRequestParser(type)(val);
       case isTypeSecp256k1Point(type): {
         const pubKeyETH = removeHexPrefix(toHex(val)).padStart(128, "0");
         const pubKeyETHy = uint256(addHexPrefix(pubKeyETH.slice(-64)));
@@ -6208,7 +7818,7 @@ ${indent}}` : "}";
         ];
       }
       default:
-        return felt(val);
+        return parser.getRequestParser(CairoFelt252.abiSelector)(val);
     }
   }
   function parseTuple(element, typeStr) {
@@ -6228,16 +7838,13 @@ ${indent}}` : "}";
       };
     });
   }
-  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) {
+  function parseCalldataValue({
+    element,
+    type,
+    structs,
+    enums,
+    parser
+  }) {
     if (element === void 0) {
       throw Error(`Missing parameter for type ${type}`);
     }
@@ -6257,7 +7864,9 @@ ${indent}}` : "}";
         throw new Error(`ABI type ${type}: not an Array representing a cairo.fixedArray() provided.`);
       }
       return values.reduce((acc, it) => {
-        return acc.concat(parseCalldataValue(it, arrayType, structs, enums));
+        return acc.concat(
+          parseCalldataValue({ element: it, type: arrayType, structs, enums, parser })
+        );
       }, []);
     }
     if (Array.isArray(element)) {
@@ -6265,37 +7874,51 @@ ${indent}}` : "}";
       result.push(felt(element.length));
       const arrayType = getArrayType(type);
       return element.reduce((acc, it) => {
-        return acc.concat(parseCalldataValue(it, arrayType, structs, enums));
+        return acc.concat(
+          parseCalldataValue({ element: it, type: arrayType, structs, enums, parser })
+        );
       }, result);
     }
+    if (CairoUint256.isAbiType(type)) {
+      return parser.getRequestParser(type)(element);
+    }
+    if (CairoUint512.isAbiType(type)) {
+      return parser.getRequestParser(type)(element);
+    }
     if (structs[type] && structs[type].members.length) {
-      if (CairoUint256.isAbiType(type)) {
-        return new CairoUint256(element).toApiRequest();
+      if (isTypeEthAddress(type)) {
+        return parseBaseTypes({ type, val: element, parser });
       }
-      if (CairoUint512.isAbiType(type)) {
-        return new CairoUint512(element).toApiRequest();
+      if (CairoByteArray.isAbiType(type)) {
+        return parser.getRequestParser(type)(element);
       }
-      if (isTypeEthAddress(type)) return parseBaseTypes(type, element);
-      if (isTypeByteArray(type)) 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));
+        return acc.concat(
+          parseCalldataValue({
+            element: subElement[it.name],
+            type: it.type,
+            structs,
+            enums,
+            parser
+          })
+        );
       }, []);
     }
     if (isTypeTuple(type)) {
       const tupled = parseTuple(element, type);
       return tupled.reduce((acc, it) => {
-        const parsedData = parseCalldataValue(it.element, it.type, structs, enums);
+        const parsedData = parseCalldataValue({
+          element: it.element,
+          type: it.type,
+          structs,
+          enums,
+          parser
+        });
         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)) {
@@ -6309,12 +7932,13 @@ ${indent}}` : "}";
           if (typeVariantSome === "()") {
             return CairoOptionVariant.Some.toString();
           }
-          const parsedParameter2 = parseCalldataValue(
-            myOption.unwrap(),
-            typeVariantSome,
+          const parsedParameter2 = parseCalldataValue({
+            element: myOption.unwrap(),
+            type: typeVariantSome,
             structs,
-            enums
-          );
+            enums,
+            parser
+          });
           if (Array.isArray(parsedParameter2)) {
             return [CairoOptionVariant.Some.toString(), ...parsedParameter2];
           }
@@ -6333,12 +7957,13 @@ ${indent}}` : "}";
           if (typeVariantOk === "()") {
             return CairoResultVariant.Ok.toString();
           }
-          const parsedParameter3 = parseCalldataValue(
-            myResult.unwrap(),
-            typeVariantOk,
+          const parsedParameter3 = parseCalldataValue({
+            element: myResult.unwrap(),
+            type: typeVariantOk,
             structs,
-            enums
-          );
+            enums,
+            parser
+          });
           if (Array.isArray(parsedParameter3)) {
             return [CairoResultVariant.Ok.toString(), ...parsedParameter3];
           }
@@ -6352,7 +7977,13 @@ ${indent}}` : "}";
         if (typeVariantErr === "()") {
           return CairoResultVariant.Err.toString();
         }
-        const parsedParameter2 = parseCalldataValue(myResult.unwrap(), typeVariantErr, structs, enums);
+        const parsedParameter2 = parseCalldataValue({
+          element: myResult.unwrap(),
+          type: typeVariantErr,
+          structs,
+          enums,
+          parser
+        });
         if (Array.isArray(parsedParameter2)) {
           return [CairoResultVariant.Err.toString(), ...parsedParameter2];
         }
@@ -6369,21 +8000,33 @@ ${indent}}` : "}";
       if (typeActiveVariant === "()") {
         return numActiveVariant.toString();
       }
-      const parsedParameter = parseCalldataValue(myEnum.unwrap(), typeActiveVariant, structs, enums);
+      const parsedParameter = parseCalldataValue({
+        element: myEnum.unwrap(),
+        type: typeActiveVariant,
+        structs,
+        enums,
+        parser
+      });
       if (Array.isArray(parsedParameter)) {
         return [numActiveVariant.toString(), ...parsedParameter];
       }
       return [numActiveVariant.toString(), parsedParameter];
     }
     if (isTypeNonZero(type)) {
-      return parseBaseTypes(getArrayType(type), element);
+      return parseBaseTypes({ type: getArrayType(type), val: element, parser });
     }
     if (typeof element === "object") {
       throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
     }
-    return parseBaseTypes(type, element);
+    return parseBaseTypes({ type, val: element, parser });
   }
-  function parseCalldataField(argsIterator, input, structs, enums) {
+  function parseCalldataField({
+    argsIterator,
+    input,
+    structs,
+    enums,
+    parser
+  }) {
     const { name, type } = input;
     let { value } = argsIterator.next();
     switch (true) {
@@ -6392,7 +8035,7 @@ ${indent}}` : "}";
         if (!Array.isArray(value) && !(typeof value === "object")) {
           throw Error(`ABI expected parameter ${name} to be an array or an object, got ${value}`);
         }
-        return parseCalldataValue(value, input.type, structs, enums);
+        return parseCalldataValue({ element: value, type: input.type, structs, enums, parser });
       // Normal Array
       case isTypeArray(type):
         if (!Array.isArray(value) && !isText(value)) {
@@ -6401,51 +8044,71 @@ ${indent}}` : "}";
         if (isString(value)) {
           value = splitLongString(value);
         }
-        return parseCalldataValue(value, input.type, structs, enums);
+        return parseCalldataValue({ element: value, type: input.type, structs, enums, parser });
       case isTypeNonZero(type):
-        return parseBaseTypes(getArrayType(type), value);
+        return parseBaseTypes({ type: getArrayType(type), val: value, parser });
       case isTypeEthAddress(type):
-        return parseBaseTypes(type, value);
+        return parseBaseTypes({ type, val: value, parser });
       // Struct or Tuple
       case (isTypeStruct(type, structs) || isTypeTuple(type) || CairoUint256.isAbiType(type)):
-        return parseCalldataValue(value, type, structs, enums);
+        return parseCalldataValue({
+          element: value,
+          type,
+          structs,
+          enums,
+          parser
+        });
       // Enums
       case isTypeEnum(type, enums):
-        return parseCalldataValue(
-          value,
+        return parseCalldataValue({
+          element: value,
           type,
           structs,
-          enums
-        );
+          enums,
+          parser
+        });
       // Felt or unhandled
       default:
-        return parseBaseTypes(type, value);
+        return parseBaseTypes({ type, val: value, parser });
     }
   }
 
   // src/utils/calldata/responseParser.ts
-  function parseBaseTypes2(type, it) {
+  function parseBaseTypes2(type, it, parser) {
     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();
+        return parser.getResponseParser(type)(it);
       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();
+        return parser.getResponseParser(type)(it);
+      case CairoUint8.isAbiType(type):
+        return parser.getResponseParser(type)(it);
+      case CairoUint16.isAbiType(type):
+        return parser.getResponseParser(type)(it);
+      case CairoUint64.isAbiType(type):
+        return parser.getResponseParser(type)(it);
+      case CairoUint96.isAbiType(type):
+        return parser.getResponseParser(type)(it);
+      case CairoUint128.isAbiType(type):
+        return parser.getResponseParser(type)(it);
+      case CairoInt8.isAbiType(type):
+        return parser.getResponseParser(type)(it);
+      case CairoInt16.isAbiType(type):
+        return parser.getResponseParser(type)(it);
+      case CairoInt32.isAbiType(type):
+        return parser.getResponseParser(type)(it);
+      case CairoInt64.isAbiType(type):
+        return parser.getResponseParser(type)(it);
+      case CairoInt128.isAbiType(type):
+        return parser.getResponseParser(type)(it);
       case isTypeEthAddress(type):
         temp = it.next().value;
         return BigInt(temp);
-      case isTypeBytes31(type):
-        temp = it.next().value;
-        return decodeShortString(temp);
+      case CairoBytes31.isAbiType(type):
+        return parser.getResponseParser(type)(it);
       case isTypeSecp256k1Point(type):
         const xLow = removeHexPrefix(it.next().value).padStart(32, "0");
         const xHigh = removeHexPrefix(it.next().value).padStart(32, "0");
@@ -6454,47 +8117,28 @@ ${indent}}` : "}";
         const pubK = BigInt(addHexPrefix(xHigh + xLow + yHigh + yLow));
         return pubK;
       default:
-        temp = it.next().value;
-        return BigInt(temp);
+        return parser.getResponseParser(CairoFelt252.abiSelector)(it);
     }
   }
-  function parseResponseValue(responseIterator, element, structs, enums) {
+  function parseResponseValue(responseIterator, element, parser, structs, enums) {
     if (element.type === "()") {
       return {};
     }
     if (CairoUint256.isAbiType(element.type)) {
-      const low = responseIterator.next().value;
-      const high = responseIterator.next().value;
-      return new CairoUint256(low, high).toBigInt();
+      return parser.getResponseParser(element.type)(responseIterator);
     }
     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();
-    }
-    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);
+      return parser.getResponseParser(element.type)(responseIterator);
+    }
+    if (CairoByteArray.isAbiType(element.type)) {
+      return parser.getResponseParser(element.type)(responseIterator);
     }
     if (CairoFixedArray.isTypeFixedArray(element.type)) {
       const parsedDataArr = [];
       const el = { name: "", type: CairoFixedArray.getFixedArrayType(element.type) };
       const arraySize = CairoFixedArray.getFixedArraySize(element.type);
       while (parsedDataArr.length < arraySize) {
-        parsedDataArr.push(parseResponseValue(responseIterator, el, structs, enums));
+        parsedDataArr.push(parseResponseValue(responseIterator, el, parser, structs, enums));
       }
       return parsedDataArr;
     }
@@ -6503,20 +8147,20 @@ ${indent}}` : "}";
       const el = { name: "", type: getArrayType(element.type) };
       const len = BigInt(responseIterator.next().value);
       while (parsedDataArr.length < len) {
-        parsedDataArr.push(parseResponseValue(responseIterator, el, structs, enums));
+        parsedDataArr.push(parseResponseValue(responseIterator, el, parser, structs, enums));
       }
       return parsedDataArr;
     }
     if (isTypeNonZero(element.type)) {
       const el = { name: "", type: getArrayType(element.type) };
-      return parseResponseValue(responseIterator, el, structs, enums);
+      return parseResponseValue(responseIterator, el, parser, structs, enums);
     }
     if (structs && element.type in structs && structs[element.type]) {
       if (isTypeEthAddress(element.type)) {
-        return parseBaseTypes2(element.type, responseIterator);
+        return parseBaseTypes2(element.type, responseIterator, parser);
       }
       return structs[element.type].members.reduce((acc, el) => {
-        acc[el.name] = parseResponseValue(responseIterator, el, structs, enums);
+        acc[el.name] = parseResponseValue(responseIterator, el, parser, structs, enums);
         return acc;
       }, {});
     }
@@ -6527,6 +8171,7 @@ ${indent}}` : "}";
           acc[variant.name] = parseResponseValue(
             responseIterator,
             { name: "", type: variant.type },
+            parser,
             structs,
             enums
           );
@@ -6557,7 +8202,7 @@ ${indent}}` : "}";
         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);
+        acc[name] = parseResponseValue(responseIterator, el, parser, structs, enums);
         return acc;
       }, {});
     }
@@ -6566,13 +8211,20 @@ ${indent}}` : "}";
       const el = { name: "", type: getArrayType(element.type) };
       const len = BigInt(responseIterator.next().value);
       while (parsedDataArr.length < len) {
-        parsedDataArr.push(parseResponseValue(responseIterator, el, structs, enums));
+        parsedDataArr.push(parseResponseValue(responseIterator, el, parser, structs, enums));
       }
       return parsedDataArr;
     }
-    return parseBaseTypes2(element.type, responseIterator);
+    return parseBaseTypes2(element.type, responseIterator, parser);
   }
-  function responseParser(responseIterator, output, structs, enums, parsedResult) {
+  function responseParser({
+    responseIterator,
+    output,
+    structs,
+    enums,
+    parsedResult,
+    parser
+  }) {
     const { name, type } = output;
     let temp;
     switch (true) {
@@ -6580,14 +8232,14 @@ ${indent}}` : "}";
         temp = responseIterator.next().value;
         return BigInt(temp);
       case (structs && type in structs || isTypeTuple(type)):
-        return parseResponseValue(responseIterator, output, structs, enums);
+        return parseResponseValue(responseIterator, output, parser, structs, enums);
       case (enums && isTypeEnum(type, enums)):
-        return parseResponseValue(responseIterator, output, structs, enums);
+        return parseResponseValue(responseIterator, output, parser, structs, enums);
       case CairoFixedArray.isTypeFixedArray(type):
-        return parseResponseValue(responseIterator, output, structs, enums);
+        return parseResponseValue(responseIterator, output, parser, structs, enums);
       case isTypeArray(type):
         if (isCairo1Type(type)) {
-          return parseResponseValue(responseIterator, output, structs, enums);
+          return parseResponseValue(responseIterator, output, parser, structs, enums);
         }
         const parsedDataArr = [];
         if (parsedResult && parsedResult[`${name}_len`]) {
@@ -6597,6 +8249,7 @@ ${indent}}` : "}";
               parseResponseValue(
                 responseIterator,
                 { name, type: output.type.replace("*", "") },
+                parser,
                 structs,
                 enums
               )
@@ -6605,9 +8258,9 @@ ${indent}}` : "}";
         }
         return parsedDataArr;
       case isTypeNonZero(type):
-        return parseResponseValue(responseIterator, output, structs, enums);
+        return parseResponseValue(responseIterator, output, parser, structs, enums);
       default:
-        return parseBaseTypes2(type, responseIterator);
+        return parseBaseTypes2(type, responseIterator, parser);
     }
   }
 
@@ -6625,16 +8278,6 @@ ${indent}}` : "}";
       `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`
     );
   };
-  var validateBytes31 = (parameter, input) => {
-    assert(isString(parameter), `Validate: arg ${input.name} should be a string.`);
-    assert(
-      parameter.length < 32,
-      `Validate: arg ${input.name} cairo typed ${input.type} should be a string of less than 32 characters.`
-    );
-  };
-  var validateByteArray = (parameter, input) => {
-    assert(isString(parameter), `Validate: arg ${input.name} should be a string.`);
-  };
   var validateUint = (parameter, input) => {
     if (isNumber2(parameter)) {
       assert(
@@ -6886,8 +8529,8 @@ ${indent}}` : "}";
         case isTypeFelt(input.type):
           validateFelt(parameter, input);
           break;
-        case isTypeBytes31(input.type):
-          validateBytes31(parameter, input);
+        case CairoBytes31.isAbiType(input.type):
+          CairoBytes31.validate(parameter);
           break;
         case (isTypeUint(input.type) || isTypeLiteral(input.type)):
           validateUint(parameter, input);
@@ -6895,8 +8538,23 @@ ${indent}}` : "}";
         case isTypeBool(input.type):
           validateBool(parameter, input);
           break;
-        case isTypeByteArray(input.type):
-          validateByteArray(parameter, input);
+        case CairoByteArray.isAbiType(input.type):
+          CairoByteArray.validate(parameter);
+          break;
+        case CairoInt8.isAbiType(input.type):
+          CairoInt8.validate(parameter);
+          break;
+        case CairoInt16.isAbiType(input.type):
+          CairoInt16.validate(parameter);
+          break;
+        case CairoInt32.isAbiType(input.type):
+          CairoInt32.validate(parameter);
+          break;
+        case CairoInt64.isAbiType(input.type):
+          CairoInt64.validate(parameter);
+          break;
+        case CairoInt128.isAbiType(input.type):
+          CairoInt128.validate(parameter);
           break;
         case (isTypeArray(input.type) || CairoFixedArray.isTypeFixedArray(input.type)):
           validateArray(parameter, input, structs, enums);
@@ -6928,10 +8586,10 @@ ${indent}}` : "}";
     parser;
     structs;
     enums;
-    constructor(abi) {
+    constructor(abi, parsingStrategy) {
       this.structs = _CallData.getAbiStruct(abi);
       this.enums = _CallData.getAbiEnum(abi);
-      this.parser = createAbiParser(abi);
+      this.parser = createAbiParser(abi, parsingStrategy);
       this.abi = this.parser.getLegacyFormat();
     }
     /**
@@ -7000,7 +8658,15 @@ ${indent}}` : "}";
       }
       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)),
+        (acc, input) => isLen(input.name) && !isCairo1Type(input.type) ? acc : acc.concat(
+          parseCalldataField({
+            argsIterator,
+            input,
+            structs: this.structs,
+            enums: this.enums,
+            parser: this.parser
+          })
+        ),
         []
       );
       Object.defineProperty(callArray, "__compiled__", {
@@ -7087,7 +8753,14 @@ ${indent}}` : "}";
       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);
+        acc[propName] = responseParser({
+          responseIterator,
+          output,
+          structs: this.structs,
+          enums: this.enums,
+          parsedResult: acc,
+          parser: this.parser
+        });
         if (acc[propName] && acc[`${propName}_len`]) {
           delete acc[`${propName}_len`];
         }
@@ -7167,12 +8840,13 @@ ${indent}}` : "}";
       const typeCairoArray = Array.isArray(typeCairo) ? typeCairo : [typeCairo];
       const responseIterator = response.flat()[Symbol.iterator]();
       const decodedArray = typeCairoArray.map(
-        (typeParam) => responseParser(
+        (typeParam) => responseParser({
           responseIterator,
-          { name: "", type: typeParam },
-          this.structs,
-          this.enums
-        )
+          output: { name: "", type: typeParam },
+          parser: this.parser,
+          structs: this.structs,
+          enums: this.enums
+        })
       );
       return decodedArray.length === 1 ? decodedArray[0] : decodedArray;
     }
@@ -7635,7 +9309,7 @@ ${indent}}` : "}";
     intDAM: () => intDAM,
     randomAddress: () => randomAddress,
     resourceBoundsToBigInt: () => resourceBoundsToBigInt,
-    resourceBoundsToEstimateFee: () => resourceBoundsToEstimateFee,
+    resourceBoundsToEstimateFeeResponse: () => resourceBoundsToEstimateFeeResponse,
     resourceBoundsToHexString: () => resourceBoundsToHexString,
     signatureToDecimalArray: () => signatureToDecimalArray,
     signatureToHexArray: () => signatureToHexArray,
@@ -7643,7 +9317,8 @@ ${indent}}` : "}";
     toOverheadOverallFee: () => toOverheadOverallFee,
     toOverheadResourceBounds: () => toOverheadResourceBounds,
     toTransactionVersion: () => toTransactionVersion,
-    v3Details: () => v3Details
+    v3Details: () => v3Details,
+    zeroResourceBounds: () => zeroResourceBounds
   });
 
   // node_modules/pako/dist/pako.esm.mjs
@@ -11854,26 +13529,44 @@ ${indent}}` : "}";
   function signatureToHexArray(sig) {
     return bigNumberishArrayToHexadecimalStringArray(formatSignature(sig));
   }
+  function zeroResourceBounds() {
+    return toOverheadResourceBounds(ZeroFeeEstimate(), false);
+  }
   function toOverheadResourceBounds(estimate, overhead = config.get("resourceBoundsOverhead")) {
     return {
       l2_gas: {
-        max_amount: addPercent(estimate.l2_gas_consumed, overhead.l2_gas.max_amount),
-        max_price_per_unit: addPercent(estimate.l2_gas_price, overhead.l2_gas.max_price_per_unit)
+        max_amount: addPercent(
+          estimate.l2_gas_consumed,
+          overhead !== false ? overhead.l2_gas.max_amount : 0
+        ),
+        max_price_per_unit: addPercent(
+          estimate.l2_gas_price,
+          overhead !== false ? overhead.l2_gas.max_price_per_unit : 0
+        )
       },
       l1_gas: {
-        max_amount: addPercent(estimate.l1_gas_consumed, overhead.l1_gas.max_amount),
-        max_price_per_unit: addPercent(estimate.l1_gas_price, overhead.l1_gas.max_price_per_unit)
+        max_amount: addPercent(
+          estimate.l1_gas_consumed,
+          overhead !== false ? overhead.l1_gas.max_amount : 0
+        ),
+        max_price_per_unit: addPercent(
+          estimate.l1_gas_price,
+          overhead !== false ? overhead.l1_gas.max_price_per_unit : 0
+        )
       },
       l1_data_gas: {
-        max_amount: addPercent(estimate.l1_data_gas_consumed, overhead.l1_data_gas.max_amount),
+        max_amount: addPercent(
+          estimate.l1_data_gas_consumed,
+          overhead !== false ? overhead.l1_data_gas.max_amount : 0
+        ),
         max_price_per_unit: addPercent(
           estimate.l1_data_gas_price,
-          overhead.l1_data_gas.max_price_per_unit
+          overhead !== false ? overhead.l1_data_gas.max_price_per_unit : 0
         )
       }
     };
   }
-  function resourceBoundsToEstimateFee(resourceBounds) {
+  function resourceBoundsToEstimateFeeResponse(resourceBounds) {
     return {
       resourceBounds,
       /**
@@ -11884,7 +13577,16 @@ ${indent}}` : "}";
     };
   }
   function toOverheadOverallFee(estimate, overhead = config.get("resourceBoundsOverhead")) {
-    return addPercent(estimate.l1_gas_consumed, overhead.l1_gas.max_amount) * addPercent(estimate.l1_gas_price, overhead.l1_gas.max_price_per_unit) + addPercent(estimate.l1_data_gas_consumed, overhead.l1_data_gas.max_amount) * addPercent(estimate.l1_data_gas_price, overhead.l1_data_gas.max_price_per_unit) + addPercent(estimate.l2_gas_consumed, overhead.l2_gas.max_amount) * addPercent(estimate.l2_gas_price, overhead.l2_gas.max_price_per_unit);
+    return addPercent(estimate.l1_gas_consumed, overhead !== false ? overhead.l1_gas.max_amount : 0) * addPercent(
+      estimate.l1_gas_price,
+      overhead !== false ? overhead.l1_gas.max_price_per_unit : 0
+    ) + addPercent(
+      estimate.l1_data_gas_consumed,
+      overhead !== false ? overhead.l1_data_gas.max_amount : 0
+    ) * addPercent(
+      estimate.l1_data_gas_price,
+      overhead !== false ? overhead.l1_data_gas.max_price_per_unit : 0
+    ) + addPercent(estimate.l2_gas_consumed, overhead !== false ? overhead.l2_gas.max_amount : 0) * addPercent(estimate.l2_gas_price, overhead !== false ? overhead.l2_gas.max_price_per_unit : 0);
   }
   function ZeroFeeEstimate() {
     return {
@@ -11929,7 +13631,7 @@ ${indent}}` : "}";
       accountDeploymentData: details.accountDeploymentData || [],
       nonceDataAvailabilityMode: details.nonceDataAvailabilityMode || EDataAvailabilityMode3.L1,
       feeDataAvailabilityMode: details.feeDataAvailabilityMode || EDataAvailabilityMode3.L1,
-      resourceBounds: details.resourceBounds ?? toOverheadResourceBounds(ZeroFeeEstimate(), void 0)
+      resourceBounds: details.resourceBounds ?? zeroResourceBounds()
     };
   }
   function getFullPublicKey(privateKey) {
@@ -11999,114 +13701,6 @@ ${indent}}` : "}";
     return { ...contract, program: decompressProgram(contract.program) };
   }
 
-  // src/utils/errors/rpc.ts
-  var errorCodes = {
-    FAILED_TO_RECEIVE_TXN: 1,
-    NO_TRACE_AVAILABLE: 10,
-    CONTRACT_NOT_FOUND: 20,
-    ENTRYPOINT_NOT_FOUND: 21,
-    BLOCK_NOT_FOUND: 24,
-    INVALID_TXN_INDEX: 27,
-    CLASS_HASH_NOT_FOUND: 28,
-    TXN_HASH_NOT_FOUND: 29,
-    PAGE_SIZE_TOO_BIG: 31,
-    NO_BLOCKS: 32,
-    INVALID_CONTINUATION_TOKEN: 33,
-    TOO_MANY_KEYS_IN_FILTER: 34,
-    CONTRACT_ERROR: 40,
-    TRANSACTION_EXECUTION_ERROR: 41,
-    STORAGE_PROOF_NOT_SUPPORTED: 42,
-    CLASS_ALREADY_DECLARED: 51,
-    INVALID_TRANSACTION_NONCE: 52,
-    INSUFFICIENT_RESOURCES_FOR_VALIDATE: 53,
-    INSUFFICIENT_ACCOUNT_BALANCE: 54,
-    VALIDATION_FAILURE: 55,
-    COMPILATION_FAILED: 56,
-    CONTRACT_CLASS_SIZE_IS_TOO_LARGE: 57,
-    NON_ACCOUNT: 58,
-    DUPLICATE_TX: 59,
-    COMPILED_CLASS_HASH_MISMATCH: 60,
-    UNSUPPORTED_TX_VERSION: 61,
-    UNSUPPORTED_CONTRACT_CLASS_VERSION: 62,
-    UNEXPECTED_ERROR: 63,
-    INVALID_SUBSCRIPTION_ID: 66,
-    TOO_MANY_ADDRESSES_IN_FILTER: 67,
-    TOO_MANY_BLOCKS_BACK: 68,
-    COMPILATION_ERROR: 100,
-    INVALID_ADDRESS: 150,
-    TOKEN_NOT_SUPPORTED: 151,
-    INVALID_SIGNATURE: 153,
-    MAX_AMOUNT_TOO_LOW: 154,
-    CLASS_HASH_NOT_SUPPORTED: 155,
-    PAYMASTER_TRANSACTION_EXECUTION_ERROR: 156,
-    INVALID_TIME_BOUNDS: 157,
-    INVALID_DEPLOYMENT_DATA: 158,
-    INVALID_CLASS_HASH: 159,
-    INVALID_ID: 160,
-    UNKNOWN_ERROR: 163
-  };
-  var rpc_default = errorCodes;
-
-  // src/utils/errors/index.ts
-  function fixStack(target, fn = target.constructor) {
-    const { captureStackTrace } = Error;
-    captureStackTrace && captureStackTrace(target, fn);
-  }
-  function fixProto(target, prototype) {
-    const { setPrototypeOf } = Object;
-    setPrototypeOf ? setPrototypeOf(target, prototype) : target.__proto__ = prototype;
-  }
-  var CustomError = class extends Error {
-    name;
-    constructor(message) {
-      super(message);
-      Object.defineProperty(this, "name", {
-        value: new.target.name,
-        enumerable: false,
-        configurable: true
-      });
-      fixProto(this, new.target.prototype);
-      fixStack(this);
-    }
-  };
-  var LibraryError = class extends CustomError {
-  };
-  var RpcError = class extends LibraryError {
-    constructor(baseError, method, params) {
-      super(`RPC: ${method} with params ${stringify2(params, null, 2)}
-
-      ${baseError.code}: ${baseError.message}: ${stringify2(baseError.data)}`);
-      this.baseError = baseError;
-      this.request = { method, params };
-    }
-    request;
-    get code() {
-      return this.baseError.code;
-    }
-    /**
-     * Verifies the underlying RPC error, also serves as a type guard for the _baseError_ property
-     * @example
-     * ```typescript
-     * SomeError.isType('UNEXPECTED_ERROR');
-     * ```
-     */
-    isType(typeName) {
-      return rpc_default[typeName] === this.code;
-    }
-  };
-  var TimeoutError = class extends LibraryError {
-    constructor(message) {
-      super(message);
-      this.name = "TimeoutError";
-    }
-  };
-  var WebSocketNotConnectedError = class extends LibraryError {
-    constructor(message) {
-      super(message);
-      this.name = "WebSocketNotConnectedError";
-    }
-  };
-
   // src/utils/eth.ts
   var eth_exports = {};
   __export(eth_exports, {
@@ -12326,7 +13920,7 @@ ${indent}}` : "}";
     tag = null;
     setIdentifier(__identifier) {
       if (isString(__identifier)) {
-        if (isDecimalString(__identifier)) {
+        if (isDecimalString2(__identifier)) {
           this.number = parseInt(__identifier, 10);
         } else if (isHex2(__identifier)) {
           this.hash = __identifier;
@@ -12775,11 +14369,13 @@ ${indent}}` : "}";
         esm_exports.ETransactionStatus.ACCEPTED_ON_L2,
         esm_exports.ETransactionStatus.ACCEPTED_ON_L1
       ];
+      const txLife = [];
       let txStatus;
       while (!onchain) {
         await wait(retryInterval);
         try {
           txStatus = await this.getTransactionStatus(transactionHash);
+          txLife.push(txStatus.finality_status);
           const executionStatus = txStatus.execution_status;
           const finalityStatus = txStatus.finality_status;
           if (!finalityStatus) {
@@ -12799,6 +14395,18 @@ ${indent}}` : "}";
           if (error instanceof Error && isErrorState) {
             throw error;
           }
+          if (error instanceof RpcError && error.isType("TXN_HASH_NOT_FOUND")) {
+            logger.info("txLife: ", txLife);
+            const errorMessages = {
+              [esm_exports2.ETransactionStatus.RECEIVED]: SYSTEM_MESSAGES.txEvictedFromMempool,
+              [esm_exports2.ETransactionStatus.PRE_CONFIRMED]: SYSTEM_MESSAGES.consensusFailed,
+              [esm_exports2.ETransactionStatus.CANDIDATE]: SYSTEM_MESSAGES.txFailsBlockBuildingValidation
+            };
+            const errorMessage = errorMessages[txLife.at(-1)];
+            if (errorMessage) {
+              throw new Error(errorMessage);
+            }
+          }
           if (retries <= 0) {
             throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
           }
@@ -13348,11 +14956,13 @@ ${indent}}` : "}";
         esm_exports2.ETransactionFinalityStatus.ACCEPTED_ON_L2,
         esm_exports2.ETransactionFinalityStatus.ACCEPTED_ON_L1
       ];
+      const txLife = [];
       let txStatus;
       while (!onchain) {
         await wait(retryInterval);
         try {
           txStatus = await this.getTransactionStatus(transactionHash);
+          txLife.push(txStatus.finality_status);
           const executionStatus = txStatus.execution_status;
           const finalityStatus = txStatus.finality_status;
           if (!finalityStatus) {
@@ -13372,6 +14982,18 @@ ${indent}}` : "}";
           if (error instanceof Error && isErrorState) {
             throw error;
           }
+          if (error instanceof RpcError && error.isType("TXN_HASH_NOT_FOUND")) {
+            logger.info("txLife: ", txLife);
+            const errorMessages = {
+              [esm_exports2.ETransactionStatus.RECEIVED]: SYSTEM_MESSAGES.txEvictedFromMempool,
+              [esm_exports2.ETransactionStatus.PRE_CONFIRMED]: SYSTEM_MESSAGES.consensusFailed,
+              [esm_exports2.ETransactionStatus.CANDIDATE]: SYSTEM_MESSAGES.txFailsBlockBuildingValidation
+            };
+            const errorMessage = errorMessages[txLife.at(-1)];
+            if (errorMessage) {
+              throw new Error(errorMessage);
+            }
+          }
           if (retries <= 0) {
             throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
           }
@@ -14417,56 +16039,123 @@ ${indent}}` : "}";
     statusReceipt;
     value;
     constructor(receipt) {
-      [this.statusReceipt, this.value] = _ReceiptTx.isSuccess(receipt) ? ["success", receipt] : _ReceiptTx.isReverted(receipt) ? ["reverted", receipt] : ["error", new Error("Unknown response type")];
-      for (const [key] of Object.entries(this)) {
-        Object.defineProperty(this, key, {
-          enumerable: false
-        });
-      }
-      for (const [key, value] of Object.entries(receipt)) {
-        Object.defineProperty(this, key, {
-          enumerable: true,
+      Object.assign(this, receipt);
+      const [statusReceipt, value] = _ReceiptTx.isSuccess(receipt) ? ["SUCCEEDED", receipt] : _ReceiptTx.isReverted(receipt) ? ["REVERTED", receipt] : ["ERROR", new Error("Unknown response type")];
+      Object.defineProperties(this, {
+        statusReceipt: {
+          value: statusReceipt,
           writable: false,
-          value
-        });
-      }
-    }
-    match(callbacks) {
-      if (this.statusReceipt in callbacks) {
-        return callbacks[this.statusReceipt](this.value);
-      }
-      return callbacks._();
-    }
-    isSuccess() {
-      return this.statusReceipt === "success";
-    }
-    isReverted() {
-      return this.statusReceipt === "reverted";
-    }
-    // TODO: Missing is Pending or Production block
-    // Status do not exist on receipts
-    /*   isRejected(): this is RejectedTransactionReceiptResponse {
-      return this.statusReceipt === 'rejected';
-    } */
-    isError() {
-      return this.statusReceipt === "error";
+          enumerable: false,
+          configurable: false
+        },
+        value: {
+          value,
+          writable: false,
+          enumerable: false,
+          configurable: false
+        },
+        match: {
+          value(callbacks) {
+            return statusReceipt in callbacks ? callbacks[statusReceipt](value) : callbacks._();
+          },
+          writable: false,
+          enumerable: false,
+          configurable: false
+        },
+        isSuccess: {
+          value: () => statusReceipt === "SUCCEEDED",
+          writable: false,
+          enumerable: false,
+          configurable: false
+        },
+        isReverted: {
+          value: () => statusReceipt === "REVERTED",
+          writable: false,
+          enumerable: false,
+          configurable: false
+        },
+        isError: {
+          value: () => statusReceipt === "ERROR",
+          writable: false,
+          enumerable: false,
+          configurable: false
+        }
+      });
     }
+    match;
+    isSuccess;
+    isReverted;
+    isError;
     static isSuccess(transactionReceipt) {
       return transactionReceipt.execution_status === TransactionExecutionStatus.SUCCEEDED;
     }
     static isReverted(transactionReceipt) {
       return transactionReceipt.execution_status === TransactionExecutionStatus.REVERTED;
     }
-    // Status do not exist on receipts
-    /*   static isRejected(
-      transactionReceipt: GetTxReceiptResponseWithoutHelper
-    ): transactionReceipt is RejectedTransactionReceiptResponse {
-      return (
-        (transactionReceipt as RejectedTransactionReceiptResponse).status ===
-        TransactionExecutionStatus.REJECTED
-      );
-    } */
   };
+  var RECEIPT_CONFIG = {
+    [TransactionExecutionStatus.SUCCEEDED]: {
+      statusReceipt: "SUCCEEDED",
+      getBaseData: (receipt) => receipt,
+      getValue: (receipt) => receipt
+    },
+    [TransactionExecutionStatus.REVERTED]: {
+      statusReceipt: "REVERTED",
+      getBaseData: (receipt) => receipt,
+      getValue: (receipt) => receipt
+    }
+  };
+  function createTransactionReceipt(receipt) {
+    const config3 = RECEIPT_CONFIG[receipt.execution_status];
+    let obj;
+    if (config3) {
+      const { statusReceipt, getBaseData, getValue } = config3;
+      const value = getValue(receipt);
+      obj = {
+        ...getBaseData(receipt),
+        statusReceipt,
+        value,
+        match(callbacks) {
+          return statusReceipt in callbacks ? callbacks[statusReceipt](value) : callbacks._();
+        },
+        isSuccess() {
+          return statusReceipt === "SUCCEEDED";
+        },
+        isReverted() {
+          return statusReceipt === "REVERTED";
+        },
+        isError() {
+          return false;
+        }
+      };
+    } else {
+      const errorValue = new Error("Unknown response type");
+      obj = {
+        statusReceipt: "ERROR",
+        value: errorValue,
+        match(callbacks) {
+          return "ERROR" in callbacks ? callbacks.ERROR(errorValue) : callbacks._();
+        },
+        isSuccess() {
+          return false;
+        },
+        isReverted() {
+          return false;
+        },
+        isError() {
+          return true;
+        }
+      };
+    }
+    Object.setPrototypeOf(obj, ReceiptTx.prototype);
+    Object.defineProperty(obj, "constructor", {
+      value: ReceiptTx,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    return obj;
+  }
 
   // src/utils/typedData.ts
   var typedData_exports = {};
@@ -15135,7 +16824,7 @@ ${indent}}` : "}";
     async getTransactionReceipt(txHash) {
       const txReceiptWoHelper = await this.channel.getTransactionReceipt(txHash);
       const txReceiptWoHelperModified = this.responseParser.parseTransactionReceipt(txReceiptWoHelper);
-      return new ReceiptTx(txReceiptWoHelperModified);
+      return createTransactionReceipt(txReceiptWoHelperModified);
     }
     async getTransactionTrace(txHash) {
       return this.channel.getTransactionTrace(txHash);
@@ -15151,7 +16840,7 @@ ${indent}}` : "}";
         txHash,
         options
       );
-      return new ReceiptTx(receiptWoHelper);
+      return createTransactionReceipt(receiptWoHelper);
     }
     async getStorageAt(contractAddress, key, blockIdentifier) {
       return this.channel.getStorageAt(contractAddress, key, blockIdentifier);
@@ -16376,12 +18065,12 @@ ${indent}}` : "}";
      */
     async signRaw(msgHash) {
       addHexPrefix(
-        buf2hex(await this._transporter.send(Number("0x5a"), 2, 0, 0, Buffer.from(this.pathBuffer)))
+        buf2hex(await this._transporter.send(Number("0x5a"), 2, 0, 0, buffer_default.from(this.pathBuffer)))
       );
       const shiftedHash = toHex(BigInt(msgHash) << 4n);
       const buff2 = hexToBytes2(shiftedHash);
       const respSign2 = Uint8Array.from(
-        await this._transporter.send(Number("0x5a"), 2, 1, 0, Buffer.from(buff2))
+        await this._transporter.send(Number("0x5a"), 2, 1, 0, buffer_default.from(buff2))
       );
       const r = BigInt(addHexPrefix(buf2hex(respSign2.subarray(1, 33))));
       const s = BigInt(addHexPrefix(buf2hex(respSign2.subarray(33, 65))));
@@ -16394,7 +18083,7 @@ ${indent}}` : "}";
     async getPublicKeys() {
       const pathBuff = this.pathBuffer;
       const respGetPublic = Uint8Array.from(
-        await this._transporter.send(Number("0x5a"), 1, 0, 0, Buffer.from(pathBuff))
+        await this._transporter.send(Number("0x5a"), 1, 0, 0, buffer_default.from(pathBuff))
       );
       this.pubKey = addHexPrefix(buf2hex(respGetPublic.subarray(1, 33)));
       this.fullPubKey = addHexPrefix(buf2hex(respGetPublic.subarray(0, 65)));
@@ -16649,7 +18338,7 @@ ${indent}}` : "}";
         txDetails.accountDeploymentData.length <= 7,
         "accountDeploymentData includes more than 7 items"
       );
-      await this._transporter.send(Number("0x5a"), 3, 0, 0, Buffer.from(this.pathBuffer));
+      await this._transporter.send(Number("0x5a"), 3, 0, 0, buffer_default.from(this.pathBuffer));
       const accountAddressBuf = this.convertBnToLedger(txDetails.walletAddress);
       const tipBuf = this.convertBnToLedger(txDetails.tip);
       const chainIdBuf = this.convertBnToLedger(txDetails.chainId);
@@ -16671,30 +18360,30 @@ ${indent}}` : "}";
         nonceBuf,
         dAModeHashBuf
       ]);
-      await this._transporter.send(Number("0x5a"), 3, 1, 0, Buffer.from(dataBuf));
+      await this._transporter.send(Number("0x5a"), 3, 1, 0, buffer_default.from(dataBuf));
       const paymasterBuf = concatenateArrayBuffer(
         txDetails.paymasterData.map((value) => {
           const a = this.convertBnToLedger(value);
           return a;
         })
       );
-      await this._transporter.send(Number("0x5a"), 3, 2, 0, Buffer.from(paymasterBuf));
+      await this._transporter.send(Number("0x5a"), 3, 2, 0, buffer_default.from(paymasterBuf));
       const accountDeployDataBuf = concatenateArrayBuffer(
         txDetails.paymasterData.map((value) => {
           const a = this.convertBnToLedger(value);
           return a;
         })
       );
-      await this._transporter.send(Number("0x5a"), 3, 3, 0, Buffer.from(accountDeployDataBuf));
+      await this._transporter.send(Number("0x5a"), 3, 3, 0, buffer_default.from(accountDeployDataBuf));
       const nbCallsBuf = this.convertBnToLedger(calls.length);
-      await this._transporter.send(Number("0x5a"), 3, 4, 0, Buffer.from(nbCallsBuf));
+      await this._transporter.send(Number("0x5a"), 3, 4, 0, buffer_default.from(nbCallsBuf));
       let respSign = new Uint8Array(0);
       for (const call of calls) {
         const calldatas = this.encodeCall(call);
-        await this._transporter.send(Number("0x5a"), 3, 5, 0, Buffer.from(calldatas[0]));
+        await this._transporter.send(Number("0x5a"), 3, 5, 0, buffer_default.from(calldatas[0]));
         if (calldatas.length > 1) {
           calldatas.slice(1).forEach(async (part) => {
-            await this._transporter.send(Number("0x5a"), 3, 5, 1, Buffer.from(part));
+            await this._transporter.send(Number("0x5a"), 3, 5, 1, buffer_default.from(part));
           });
         }
         respSign = await this._transporter.send(Number("0x5a"), 3, 5, 2);
@@ -16731,7 +18420,7 @@ ${indent}}` : "}";
      * ```
      */
     async signDeployAccountV3(deployAccountDetail) {
-      await this._transporter.send(Number("0x5a"), 5, 0, 0, Buffer.from(this.pathBuffer));
+      await this._transporter.send(Number("0x5a"), 5, 0, 0, buffer_default.from(this.pathBuffer));
       const accountAddressBuf = this.convertBnToLedger(
         deployAccountDetail.contractAddress
       );
@@ -16753,7 +18442,7 @@ ${indent}}` : "}";
         classHashBuf,
         saltBuf
       ]);
-      await this._transporter.send(Number("0x5a"), 5, 1, 0, Buffer.from(dataBuf));
+      await this._transporter.send(Number("0x5a"), 5, 1, 0, buffer_default.from(dataBuf));
       const tipBuf = this.convertBnToLedger(deployAccountDetail.tip);
       const l1_gasBuf = this.convertBnToLedger(
         encodeResourceBoundsL1(deployAccountDetail.resourceBounds)
@@ -16762,17 +18451,17 @@ ${indent}}` : "}";
         encodeResourceBoundsL2(deployAccountDetail.resourceBounds)
       );
       const feeBuf = concatenateArrayBuffer([tipBuf, l1_gasBuf, l2_gasBuf]);
-      await this._transporter.send(Number("0x5a"), 5, 2, 0, Buffer.from(feeBuf));
+      await this._transporter.send(Number("0x5a"), 5, 2, 0, buffer_default.from(feeBuf));
       const paymasterBuf = concatenateArrayBuffer(
         deployAccountDetail.paymasterData.map((value) => {
           const a = this.convertBnToLedger(value);
           return a;
         })
       );
-      await this._transporter.send(Number("0x5a"), 5, 3, 0, Buffer.from(paymasterBuf));
+      await this._transporter.send(Number("0x5a"), 5, 3, 0, buffer_default.from(paymasterBuf));
       const compiledConstructor = CallData.compile(deployAccountDetail.constructorCalldata);
       const constructorLengthBuf = this.convertBnToLedger(compiledConstructor.length);
-      await this._transporter.send(Number("0x5a"), 5, 4, 0, Buffer.from(constructorLengthBuf));
+      await this._transporter.send(Number("0x5a"), 5, 4, 0, buffer_default.from(constructorLengthBuf));
       const constructorBuf = concatenateArrayBuffer(
         compiledConstructor.map((parameter) => {
           const a = this.convertBnToLedger(parameter);
@@ -16785,7 +18474,7 @@ ${indent}}` : "}";
         constructorChunks.push(constructorBuf.subarray(i, i + chunkSize));
       let respSign = new Uint8Array(0);
       for (const chunk of constructorChunks) {
-        respSign = await this._transporter.send(Number("0x5a"), 5, 5, 0, Buffer.from(chunk));
+        respSign = await this._transporter.send(Number("0x5a"), 5, 5, 0, buffer_default.from(chunk));
       }
       return this.decodeSignatureLedger(respSign);
     }
@@ -16875,7 +18564,7 @@ ${indent}}` : "}";
         txDetails.accountDeploymentData.length <= 7,
         "accountDeploymentData includes more than 7 items"
       );
-      await this._transporter.send(Number("0x5a"), 3, 0, 0, Buffer.from(this.pathBuffer));
+      await this._transporter.send(Number("0x5a"), 3, 0, 0, buffer_default.from(this.pathBuffer));
       const accountAddressBuf = this.convertBnToLedger(txDetails.walletAddress);
       const chainIdBuf = this.convertBnToLedger(txDetails.chainId);
       const nonceBuf = this.convertBnToLedger(txDetails.nonce);
@@ -16891,7 +18580,7 @@ ${indent}}` : "}";
         nonceBuf,
         dAModeHashBuf
       ]);
-      await this._transporter.send(Number("0x5a"), 3, 1, 0, Buffer.from(dataBuf));
+      await this._transporter.send(Number("0x5a"), 3, 1, 0, buffer_default.from(dataBuf));
       if (isRPC08Plus_ResourceBoundsBN(txDetails.resourceBounds)) {
         const tipBuf = this.convertBnToLedger(txDetails.tip);
         const l1_gasBuf = this.convertBnToLedger(encodeResourceBoundsL1(txDetails.resourceBounds));
@@ -16905,7 +18594,7 @@ ${indent}}` : "}";
           l2_gasBuf,
           l1_data_gasBuf
         ]);
-        await this._transporter.send(Number("0x5a"), 3, 2, 0, Buffer.from(feeBuf));
+        await this._transporter.send(Number("0x5a"), 3, 2, 0, buffer_default.from(feeBuf));
       }
       const paymasterBuf = concatenateArrayBuffer(
         txDetails.paymasterData.map((value) => {
@@ -16913,23 +18602,23 @@ ${indent}}` : "}";
           return a;
         })
       );
-      await this._transporter.send(Number("0x5a"), 3, 3, 0, Buffer.from(paymasterBuf));
+      await this._transporter.send(Number("0x5a"), 3, 3, 0, buffer_default.from(paymasterBuf));
       const accountDeployDataBuf = concatenateArrayBuffer(
         txDetails.paymasterData.map((value) => {
           const a = this.convertBnToLedger(value);
           return a;
         })
       );
-      await this._transporter.send(Number("0x5a"), 3, 4, 0, Buffer.from(accountDeployDataBuf));
+      await this._transporter.send(Number("0x5a"), 3, 4, 0, buffer_default.from(accountDeployDataBuf));
       const nbCallsBuf = this.convertBnToLedger(calls.length);
-      await this._transporter.send(Number("0x5a"), 3, 5, 0, Buffer.from(nbCallsBuf));
+      await this._transporter.send(Number("0x5a"), 3, 5, 0, buffer_default.from(nbCallsBuf));
       let respSign = new Uint8Array(0);
       for (const call of calls) {
         const calldatas = this.encodeCall(call);
-        respSign = await this._transporter.send(Number("0x5a"), 3, 6, 0, Buffer.from(calldatas[0]));
+        respSign = await this._transporter.send(Number("0x5a"), 3, 6, 0, buffer_default.from(calldatas[0]));
         if (calldatas.length > 1) {
           calldatas.slice(1).forEach(async (part) => {
-            respSign = await this._transporter.send(Number("0x5a"), 3, 6, 1, Buffer.from(part));
+            respSign = await this._transporter.send(Number("0x5a"), 3, 6, 1, buffer_default.from(part));
           });
         }
       }
@@ -16965,7 +18654,7 @@ ${indent}}` : "}";
      * ```
      */
     async signDeployAccountV3(deployAccountDetail) {
-      await this._transporter.send(Number("0x5a"), 5, 0, 0, Buffer.from(this.pathBuffer));
+      await this._transporter.send(Number("0x5a"), 5, 0, 0, buffer_default.from(this.pathBuffer));
       const accountAddressBuf = this.convertBnToLedger(
         deployAccountDetail.contractAddress
       );
@@ -16987,7 +18676,7 @@ ${indent}}` : "}";
         classHashBuf,
         saltBuf
       ]);
-      await this._transporter.send(Number("0x5a"), 5, 1, 0, Buffer.from(dataBuf));
+      await this._transporter.send(Number("0x5a"), 5, 1, 0, buffer_default.from(dataBuf));
       if (isRPC08Plus_ResourceBoundsBN(deployAccountDetail.resourceBounds)) {
         const tipBuf = this.convertBnToLedger(deployAccountDetail.tip);
         const l1_gasBuf = this.convertBnToLedger(
@@ -17005,7 +18694,7 @@ ${indent}}` : "}";
           l2_gasBuf,
           l1_data_gasBuf
         ]);
-        await this._transporter.send(Number("0x5a"), 5, 2, 0, Buffer.from(feeBuf));
+        await this._transporter.send(Number("0x5a"), 5, 2, 0, buffer_default.from(feeBuf));
       }
       const paymasterBuf = concatenateArrayBuffer(
         deployAccountDetail.paymasterData.map((value) => {
@@ -17013,10 +18702,10 @@ ${indent}}` : "}";
           return a;
         })
       );
-      await this._transporter.send(Number("0x5a"), 5, 3, 0, Buffer.from(paymasterBuf));
+      await this._transporter.send(Number("0x5a"), 5, 3, 0, buffer_default.from(paymasterBuf));
       const compiledConstructor = CallData.compile(deployAccountDetail.constructorCalldata);
       const constructorLengthBuf = this.convertBnToLedger(compiledConstructor.length);
-      await this._transporter.send(Number("0x5a"), 5, 4, 0, Buffer.from(constructorLengthBuf));
+      await this._transporter.send(Number("0x5a"), 5, 4, 0, buffer_default.from(constructorLengthBuf));
       const constructorBuf = concatenateArrayBuffer(
         compiledConstructor.map((parameter) => {
           const a = this.convertBnToLedger(parameter);
@@ -17029,7 +18718,7 @@ ${indent}}` : "}";
         constructorChunks.push(constructorBuf.subarray(i, i + chunkSize));
       let respSign = new Uint8Array(0);
       for (const chunk of constructorChunks) {
-        respSign = await this._transporter.send(Number("0x5a"), 5, 5, 0, Buffer.from(chunk));
+        respSign = await this._transporter.send(Number("0x5a"), 5, 5, 0, buffer_default.from(chunk));
       }
       return this.decodeSignatureLedger(respSign);
     }
@@ -17698,7 +19387,8 @@ ${indent}}` : "}";
     }
     async estimateFeeBulk(invocations, details = {}) {
       if (!invocations.length) throw TypeError("Invocations should be non-empty array");
-      if (details.resourceBounds) return [resourceBoundsToEstimateFee(details.resourceBounds)];
+      if (details.resourceBounds)
+        return [resourceBoundsToEstimateFeeResponse(details.resourceBounds)];
       const { nonce, blockIdentifier, version, skipValidate } = details;
       const detailsWithTip = await this.resolveDetailsWithTip(details);
       const accountInvocations = await this.accountInvocationsFactory(invocations, {
@@ -18556,7 +20246,11 @@ ${indent}}` : "}";
       Object.keys(source).forEach((key) => {
         if (isObject2(source[key])) {
           if (!(key in target)) Object.assign(output, { [key]: source[key] });
-          else output[key] = mergeAbiEvents(target[key], source[key]);
+          else
+            output[key] = mergeAbiEvents(
+              target[key],
+              source[key]
+            );
         } else {
           Object.assign(output, { [key]: source[key] });
         }
@@ -18564,7 +20258,7 @@ ${indent}}` : "}";
     }
     return output;
   }
-  function parseEvents(providerReceivedEvents, abiEvents, abiStructs, abiEnums) {
+  function parseEvents(providerReceivedEvents, abiEvents, abiStructs, abiEnums, parser) {
     const ret = providerReceivedEvents.flat().reduce((acc, recEvent) => {
       const currentEvent = JSON.parse(JSON.stringify(recEvent));
       let abiEvent = abiEvents[currentEvent.keys.shift() ?? 0];
@@ -18583,22 +20277,24 @@ ${indent}}` : "}";
       const abiEventKeys = abiEvent.members?.filter((it) => it.kind === "key") || abiEvent.keys;
       const abiEventData = abiEvent.members?.filter((it) => it.kind === "data") || abiEvent.data;
       abiEventKeys.forEach((key) => {
-        parsedEvent[abiEvent.name][key.name] = responseParser(
-          keysIter,
-          key,
-          abiStructs,
-          abiEnums,
-          parsedEvent[abiEvent.name]
-        );
+        parsedEvent[abiEvent.name][key.name] = responseParser({
+          responseIterator: keysIter,
+          output: key,
+          structs: abiStructs,
+          enums: abiEnums,
+          parser,
+          parsedResult: parsedEvent[abiEvent.name]
+        });
       });
       abiEventData.forEach((data) => {
-        parsedEvent[abiEvent.name][data.name] = responseParser(
-          dataIter,
-          data,
-          abiStructs,
-          abiEnums,
-          parsedEvent[abiEvent.name]
-        );
+        parsedEvent[abiEvent.name][data.name] = responseParser({
+          responseIterator: dataIter,
+          output: data,
+          structs: abiStructs,
+          enums: abiEnums,
+          parser,
+          parsedResult: parsedEvent[abiEvent.name]
+        });
       });
       if ("block_hash" in currentEvent) parsedEvent.block_hash = currentEvent.block_hash;
       if ("block_number" in currentEvent) parsedEvent.block_number = currentEvent.block_number;
@@ -18616,8 +20312,8 @@ ${indent}}` : "}";
       const options = { ...contract.withOptionsProps };
       contract.withOptionsProps = void 0;
       return contract.call(functionAbi.name, args, {
-        parseRequest: true,
-        parseResponse: true,
+        parseRequest: contract.parseRequest,
+        parseResponse: contract.parseResponse,
         ...options
       });
     };
@@ -18627,7 +20323,7 @@ ${indent}}` : "}";
       const options = { ...contract.withOptionsProps };
       contract.withOptionsProps = void 0;
       return contract.invoke(functionAbi.name, args, {
-        parseRequest: true,
+        parseRequest: contract.parseRequest,
         ...options
       });
     };
@@ -18655,6 +20351,8 @@ ${indent}}` : "}";
     address;
     providerOrAccount;
     classHash;
+    parseRequest;
+    parseResponse;
     structs;
     events;
     functions;
@@ -18663,6 +20361,7 @@ ${indent}}` : "}";
     estimateFee;
     callData;
     withOptionsProps;
+    parsingStrategy;
     /**
      * @param options
      *  - abi: Abi of the contract object (required)
@@ -18670,14 +20369,18 @@ ${indent}}` : "}";
      *  - providerOrAccount?: Provider or Account to attach to (fallback to defaultProvider)
      *  - parseRequest?: compile and validate arguments (optional, default true)
      *  - parseResponse?: Parse elements of the response array and structuring them into response object (optional, default true)
+     *  - parser?: Abi parser (optional, default createAbiParser(options.abi))
      */
     constructor(options) {
-      const parser = createAbiParser(options.abi);
-      this.address = options.address && options.address.toLowerCase();
+      this.parsingStrategy = options.parsingStrategy;
+      const parser = createAbiParser(options.abi, options.parsingStrategy);
       this.abi = parser.getLegacyFormat();
+      this.address = options.address && options.address.toLowerCase();
       this.providerOrAccount = options.providerOrAccount ?? defaultProvider;
+      this.parseRequest = options.parseRequest ?? true;
+      this.parseResponse = options.parseResponse ?? true;
       this.classHash = options.classHash;
-      this.callData = new CallData(options.abi);
+      this.callData = new CallData(options.abi, options.parsingStrategy);
       this.structs = CallData.getAbiStruct(options.abi);
       this.events = getAbiEvents(options.abi);
       const methodTypes = { enumerable: true, value: {}, writable: false };
@@ -18729,8 +20432,9 @@ ${indent}}` : "}";
     attach(address, abi) {
       this.address = address;
       if (abi) {
-        this.abi = createAbiParser(abi).getLegacyFormat();
-        this.callData = new CallData(abi);
+        const parser = createAbiParser(abi, this.parsingStrategy);
+        this.abi = parser.getLegacyFormat();
+        this.callData = new CallData(abi, this.parsingStrategy);
         this.structs = CallData.getAbiStruct(abi);
         this.events = getAbiEvents(abi);
       }
@@ -18776,7 +20480,8 @@ ${indent}}` : "}";
         return this.callData.parse(method, it);
       });
     }
-    invoke(method, args = [], { parseRequest = true, signature, ...RestInvokeOptions } = {}) {
+    async invoke(method, args = [], options = {}) {
+      const { parseRequest = true, signature, waitForTransaction, ...RestInvokeOptions } = options;
       assert(this.address !== null, "contract is not connected to an address");
       const calldata = getCompiledCalldata(args, () => {
         if (parseRequest) {
@@ -18792,9 +20497,17 @@ ${indent}}` : "}";
         entrypoint: method
       };
       if (isAccount(this.providerOrAccount)) {
-        return this.providerOrAccount.execute(invocation, {
+        const result = await this.providerOrAccount.execute(invocation, {
           ...RestInvokeOptions
         });
+        if (waitForTransaction) {
+          const result2 = await this.providerOrAccount.waitForTransaction(result.transaction_hash);
+          if (result2.isSuccess()) {
+            return result2;
+          }
+          throw new Error("Transaction failed", { cause: result2 });
+        }
+        return result;
       }
       if (!RestInvokeOptions.nonce)
         throw new Error(`Manual nonce is required when invoking a function without an account`);
@@ -18832,9 +20545,9 @@ ${indent}}` : "}";
     // TODO: Demistify what is going on here ???
     // TODO: receipt status filtering test and fix this do not look right
     parseEvents(receipt) {
-      let parsed;
+      let parsed = [];
       receipt.match({
-        success: (txR) => {
+        SUCCEEDED: (txR) => {
           const emittedEvents = txR.events?.map((event) => {
             return {
               // TODO: this do not check that block is production and block_hash and block_number actually exists
@@ -18847,16 +20560,26 @@ ${indent}}` : "}";
           }).filter((event) => cleanHex(event.from_address) === cleanHex(this.address), []) || [];
           parsed = parseEvents(
             emittedEvents,
-            // TODO: any temp hotfix, fix this
             this.events,
             this.structs,
-            CallData.getAbiEnum(this.abi)
+            CallData.getAbiEnum(this.abi),
+            this.callData.parser
           );
         },
         _: () => {
           throw Error("This transaction was not successful.");
         }
       });
+      Object.defineProperty(parsed, "getByPath", {
+        value: (path) => {
+          const event = parsed.find((ev) => Object.keys(ev).some((key) => key.includes(path)));
+          const eventKey = Object.keys(event || {}).find((key) => key.includes(path));
+          return eventKey && event ? event[eventKey] : null;
+        },
+        writable: false,
+        enumerable: false,
+        configurable: false
+      });
       return parsed;
     }
     isCairo1() {
@@ -18973,7 +20696,10 @@ ${indent}}` : "}";
         abi,
         address: contract_address,
         providerOrAccount: account,
-        classHash
+        classHash,
+        parseRequest: params.parseRequest,
+        parseResponse: params.parseResponse,
+        parsingStrategy: params.parsingStrategy
       });
     }
   };