starknet 8.1.2 → 8.2.0

package/dist/index.mjs

@@ -36,7 +36,16 @@ __export(constants_exports, {
   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,
@@ -81,16 +90,22 @@ __export(encode_exports, {
   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
 });
 import { base64 } from "@scure/base";
 var IS_BROWSER = typeof window !== "undefined";
@@ -98,9 +113,13 @@ var STRING_ZERO = "0";
 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);
 }
@@ -152,6 +171,61 @@ function concatenateArrayBuffer(uint8arrays) {
   });
   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;
@@ -164,8 +238,17 @@ var MAX_STORAGE_ITEM_SIZE = 256n;
 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"
@@ -232,7 +315,8 @@ var DEFAULT_GLOBAL_CONFIG = {
   },
   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/`],
@@ -250,7 +334,10 @@ var SYSTEM_MESSAGES = {
   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
@@ -473,12 +560,20 @@ var Uint = {
   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",
@@ -662,10 +757,12 @@ __export(num_exports, {
   getDecimalString: () => getDecimalString,
   getHexString: () => getHexString,
   getHexStringArray: () => getHexStringArray,
+  getNext: () => getNext,
   hexToBytes: () => hexToBytes,
   hexToDecimalString: () => hexToDecimalString,
   isBigNumberish: () => isBigNumberish,
   isHex: () => isHex,
+  isHexString: () => isHexString2,
   isStringWholeNumber: () => isStringWholeNumber,
   stringToSha256ToArrayBuff4: () => stringToSha256ToArrayBuff4,
   toBigInt: () => toBigInt,
@@ -695,14 +792,21 @@ function isBigInt(value) {
 function isString(value) {
   return typeof value === "string";
 }
+function isBuffer(obj) {
+  return typeof Buffer !== "undefined" && obj instanceof Buffer;
+}
 function isObject(item) {
   return !!item && typeof item === "object" && !Array.isArray(item);
 }
+function isInteger2(value) {
+  return Number.isInteger(value);
+}
 
 // src/utils/num.ts
 function isHex(hex) {
   return /^0[xX][0-9a-fA-F]*$/.test(hex);
 }
+var isHexString2 = isHex;
 function toBigInt(value) {
   return BigInt(value);
 }
@@ -790,6 +894,11 @@ function stringToSha256ToArrayBuff4(str) {
 function isBigNumberish(input) {
   return isNumber(input) || isBigInt(input) || isString(input) && (isHex(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 = {};
@@ -855,7 +964,7 @@ __export(shortString_exports, {
   decodeShortString: () => decodeShortString,
   encodeShortString: () => encodeShortString,
   isASCII: () => isASCII,
-  isDecimalString: () => isDecimalString,
+  isDecimalString: () => isDecimalString2,
   isLongText: () => isLongText,
   isShortString: () => isShortString,
   isShortText: () => isShortText,
@@ -868,7 +977,7 @@ function isASCII(str) {
 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) {
@@ -890,7 +999,7 @@ function decodeShortString(str) {
   if (isHex(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`);
@@ -932,12 +1041,11 @@ __export(cairo_exports, {
   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,
@@ -954,6 +1062,16 @@ __export(cairo_exports, {
   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)) {
@@ -980,6 +1098,69 @@ function CairoFelt(it) {
   }
   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) || isNumber(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;
@@ -991,11 +1172,16 @@ var UINT_256_LOW_MIN = 0n;
 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 (isObject(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) {
@@ -1014,9 +1200,15 @@ var CairoUint256 = class _CairoUint256 {
    * 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) || isObject(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;
   }
   /**
@@ -1025,12 +1217,14 @@ var CairoUint256 = class _CairoUint256 {
   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 };
   }
   /**
@@ -1050,6 +1244,11 @@ var CairoUint256 = class _CairoUint256 {
   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
    */
@@ -1090,9 +1289,13 @@ var UINT_512_MIN = 0n;
 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 (isObject(arr[0]) && arr.length === 1 && "limb0" in arr[0] && "limb1" in arr[0] && "limb2" in arr[0] && "limb3" in arr[0]) {
@@ -1126,9 +1329,15 @@ var CairoUint512 = class _CairoUint512 {
    * 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) || isObject(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;
   }
   /**
@@ -1140,9 +1349,10 @@ var CairoUint512 = class _CairoUint512 {
     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 };
   }
@@ -1163,6 +1373,13 @@ var CairoUint512 = class _CairoUint512 {
   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
    */
@@ -1217,13 +1434,12 @@ var isTypeEnum = (type, enums) => type in enums;
 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("::");
@@ -1478,15 +1694,1348 @@ function formatter(data, type, sameType) {
       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(!isObject(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+    assert(
+      !isNumber(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(
+      !isNumber(data) || Number.isInteger(data),
+      "Invalid input for CairoByteArray: decimal numbers are not supported, only integers"
+    );
+    assert(
+      !isNumber(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) || isNumber(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(!isObject(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+    assert(
+      !isNumber(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(!isObject(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+    assert(
+      !isNumber(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(!isObject(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+    assert(
+      !isNumber(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(!isObject(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+    assert(
+      !isNumber(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(!isObject(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+    assert(
+      !isNumber(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(!isObject(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+    assert(
+      !isNumber(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(!isObject(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+    assert(
+      !isNumber(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(!isObject(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+    assert(
+      !isNumber(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(!isObject(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+    assert(
+      !isNumber(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(!isObject(data) && !Array.isArray(data), "Invalid input: objects are not supported");
+    assert(
+      !isNumber(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
@@ -1517,8 +3066,22 @@ var AbiParser1 = class {
 // 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
@@ -1551,13 +3114,13 @@ var AbiParser2 = class {
 };
 
 // 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}`);
 }
@@ -1684,16 +3247,17 @@ var CairoFixedArray = class _CairoFixedArray {
         `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;
@@ -1790,6 +3354,7 @@ var CairoFixedArray = class _CairoFixedArray {
   }
   /**
    * 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.
@@ -1834,7 +3399,7 @@ function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
     if (isTypeNonZero(abiType)) {
       return unorderedItem;
     }
-    if (isTypeByteArray(abiType)) {
+    if (CairoByteArray.isAbiType(abiType)) {
       return unorderedItem;
     }
     if (isTypeU96(abiType)) {
@@ -1992,14 +3557,38 @@ function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
 }
 
 // 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)));
@@ -2012,7 +3601,7 @@ function parseBaseTypes(type, val) {
       ];
     }
     default:
-      return felt(val);
+      return parser.getRequestParser(CairoFelt252.abiSelector)(val);
   }
 }
 function parseTuple(element, typeStr) {
@@ -2032,16 +3621,13 @@ function parseTuple(element, typeStr) {
     };
   });
 }
-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}`);
   }
@@ -2061,7 +3647,9 @@ function parseCalldataValue(element, type, structs, enums) {
       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)) {
@@ -2069,37 +3657,51 @@ function parseCalldataValue(element, type, structs, enums) {
     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)) {
@@ -2113,12 +3715,13 @@ function parseCalldataValue(element, type, structs, enums) {
         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];
         }
@@ -2137,12 +3740,13 @@ function parseCalldataValue(element, type, structs, enums) {
         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];
         }
@@ -2156,7 +3760,13 @@ function parseCalldataValue(element, type, structs, enums) {
       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];
       }
@@ -2173,21 +3783,33 @@ function parseCalldataValue(element, type, structs, enums) {
     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) {
@@ -2196,7 +3818,7 @@ function parseCalldataField(argsIterator, input, structs, enums) {
       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)) {
@@ -2205,51 +3827,71 @@ function parseCalldataField(argsIterator, input, structs, enums) {
       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");
@@ -2258,47 +3900,28 @@ function parseBaseTypes2(type, it) {
       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;
   }
@@ -2307,20 +3930,20 @@ function parseResponseValue(responseIterator, element, structs, enums) {
     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;
     }, {});
   }
@@ -2331,6 +3954,7 @@ function parseResponseValue(responseIterator, element, structs, enums) {
         acc[variant.name] = parseResponseValue(
           responseIterator,
           { name: "", type: variant.type },
+          parser,
           structs,
           enums
         );
@@ -2361,7 +3985,7 @@ function parseResponseValue(responseIterator, element, structs, enums) {
       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;
     }, {});
   }
@@ -2370,13 +3994,20 @@ function parseResponseValue(responseIterator, element, structs, enums) {
     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) {
@@ -2384,14 +4015,14 @@ function responseParser(responseIterator, output, structs, enums, parsedResult)
       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`]) {
@@ -2401,6 +4032,7 @@ function responseParser(responseIterator, output, structs, enums, parsedResult)
             parseResponseValue(
               responseIterator,
               { name, type: output.type.replace("*", "") },
+              parser,
               structs,
               enums
             )
@@ -2409,9 +4041,9 @@ function responseParser(responseIterator, output, structs, enums, parsedResult)
       }
       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);
   }
 }
 
@@ -2429,16 +4061,6 @@ var validateFelt = (parameter, input) => {
     `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 (isNumber(parameter)) {
     assert(
@@ -2690,8 +4312,8 @@ function validateFields(abiMethod, args, structs, enums) {
       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);
@@ -2699,8 +4321,23 @@ function validateFields(abiMethod, args, structs, enums) {
       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);
@@ -2732,10 +4369,10 @@ var CallData = class _CallData {
   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();
   }
   /**
@@ -2804,7 +4441,15 @@ var CallData = class _CallData {
     }
     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__", {
@@ -2891,7 +4536,14 @@ var CallData = class _CallData {
     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`];
       }
@@ -2971,12 +4623,13 @@ var CallData = class _CallData {
     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;
   }
@@ -3661,114 +5314,6 @@ function contractClassResponseToLegacyCompiledContract(ccr) {
   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, {
@@ -3907,7 +5452,7 @@ var Block = class {
   tag = null;
   setIdentifier(__identifier) {
     if (isString(__identifier)) {
-      if (isDecimalString(__identifier)) {
+      if (isDecimalString2(__identifier)) {
         this.number = parseInt(__identifier, 10);
       } else if (isHex(__identifier)) {
         this.hash = __identifier;
@@ -4356,11 +5901,13 @@ var RpcChannel = class {
       RPCSPEC08.ETransactionStatus.ACCEPTED_ON_L2,
       RPCSPEC08.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) {
@@ -4380,6 +5927,18 @@ var RpcChannel = class {
         if (error instanceof Error && isErrorState) {
           throw error;
         }
+        if (error instanceof RpcError && error.isType("TXN_HASH_NOT_FOUND")) {
+          logger.info("txLife: ", txLife);
+          const errorMessages = {
+            [RPCSPEC09.ETransactionStatus.RECEIVED]: SYSTEM_MESSAGES.txEvictedFromMempool,
+            [RPCSPEC09.ETransactionStatus.PRE_CONFIRMED]: SYSTEM_MESSAGES.consensusFailed,
+            [RPCSPEC09.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}`);
         }
@@ -4929,11 +6488,13 @@ var RpcChannel2 = class {
       RPCSPEC09.ETransactionFinalityStatus.ACCEPTED_ON_L2,
       RPCSPEC09.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) {
@@ -4953,6 +6514,18 @@ var RpcChannel2 = class {
         if (error instanceof Error && isErrorState) {
           throw error;
         }
+        if (error instanceof RpcError && error.isType("TXN_HASH_NOT_FOUND")) {
+          logger.info("txLife: ", txLife);
+          const errorMessages = {
+            [RPCSPEC09.ETransactionStatus.RECEIVED]: SYSTEM_MESSAGES.txEvictedFromMempool,
+            [RPCSPEC09.ETransactionStatus.PRE_CONFIRMED]: SYSTEM_MESSAGES.consensusFailed,
+            [RPCSPEC09.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}`);
         }
@@ -5998,56 +7571,123 @@ var ReceiptTx = class _ReceiptTx {
   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 config2 = RECEIPT_CONFIG[receipt.execution_status];
+  let obj;
+  if (config2) {
+    const { statusReceipt, getBaseData, getValue } = config2;
+    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 = {};
@@ -6716,7 +8356,7 @@ var RpcProvider = class {
   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);
@@ -6732,7 +8372,7 @@ var RpcProvider = class {
       txHash,
       options
     );
-    return new ReceiptTx(receiptWoHelper);
+    return createTransactionReceipt(receiptWoHelper);
   }
   async getStorageAt(contractAddress, key, blockIdentifier) {
     return this.channel.getStorageAt(contractAddress, key, blockIdentifier);
@@ -7739,12 +9379,12 @@ var LedgerSigner111 = class {
    */
   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 = hexToBytes(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))));
@@ -7757,7 +9397,7 @@ var LedgerSigner111 = class {
   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)));
@@ -8013,7 +9653,7 @@ var LedgerSigner221 = class extends LedgerSigner111 {
       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);
@@ -8035,30 +9675,30 @@ var LedgerSigner221 = class extends LedgerSigner111 {
       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);
@@ -8095,7 +9735,7 @@ var LedgerSigner221 = class extends LedgerSigner111 {
    * ```
    */
   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
     );
@@ -8117,7 +9757,7 @@ var LedgerSigner221 = class extends LedgerSigner111 {
       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)
@@ -8126,17 +9766,17 @@ var LedgerSigner221 = class extends LedgerSigner111 {
       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);
@@ -8149,7 +9789,7 @@ var LedgerSigner221 = class extends LedgerSigner111 {
       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);
   }
@@ -8239,7 +9879,7 @@ var LedgerSigner231 = class extends LedgerSigner221 {
       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);
@@ -8255,7 +9895,7 @@ var LedgerSigner231 = class extends LedgerSigner221 {
       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));
@@ -8269,7 +9909,7 @@ var LedgerSigner231 = class extends LedgerSigner221 {
         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) => {
@@ -8277,23 +9917,23 @@ var LedgerSigner231 = class extends LedgerSigner221 {
         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));
         });
       }
     }
@@ -8329,7 +9969,7 @@ var LedgerSigner231 = class extends LedgerSigner221 {
    * ```
    */
   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
     );
@@ -8351,7 +9991,7 @@ var LedgerSigner231 = class extends LedgerSigner221 {
       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(
@@ -8369,7 +10009,7 @@ var LedgerSigner231 = class extends LedgerSigner221 {
         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) => {
@@ -8377,10 +10017,10 @@ var LedgerSigner231 = class extends LedgerSigner221 {
         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);
@@ -8393,7 +10033,7 @@ var LedgerSigner231 = class extends LedgerSigner221 {
       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);
   }
@@ -9921,7 +11561,11 @@ function mergeAbiEvents(target, source) {
     Object.keys(source).forEach((key) => {
       if (isObject(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] });
       }
@@ -9929,7 +11573,7 @@ function mergeAbiEvents(target, source) {
   }
   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];
@@ -9948,22 +11592,24 @@ function parseEvents(providerReceivedEvents, abiEvents, abiStructs, abiEnums) {
     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;
@@ -9981,8 +11627,8 @@ function buildCall(contract, functionAbi) {
     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
     });
   };
@@ -9992,7 +11638,7 @@ function buildInvoke(contract, functionAbi) {
     const options = { ...contract.withOptionsProps };
     contract.withOptionsProps = void 0;
     return contract.invoke(functionAbi.name, args, {
-      parseRequest: true,
+      parseRequest: contract.parseRequest,
       ...options
     });
   };
@@ -10020,6 +11666,8 @@ var Contract = class _Contract {
   address;
   providerOrAccount;
   classHash;
+  parseRequest;
+  parseResponse;
   structs;
   events;
   functions;
@@ -10028,6 +11676,7 @@ var Contract = class _Contract {
   estimateFee;
   callData;
   withOptionsProps;
+  parsingStrategy;
   /**
    * @param options
    *  - abi: Abi of the contract object (required)
@@ -10035,14 +11684,18 @@ var Contract = class _Contract {
    *  - 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 };
@@ -10094,8 +11747,9 @@ var Contract = class _Contract {
   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);
     }
@@ -10141,7 +11795,8 @@ var Contract = class _Contract {
       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) {
@@ -10157,9 +11812,17 @@ var Contract = class _Contract {
       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`);
@@ -10197,9 +11860,9 @@ var Contract = class _Contract {
   // 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
@@ -10212,16 +11875,26 @@ var Contract = class _Contract {
         }).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() {
@@ -10338,7 +12011,10 @@ var Contract = class _Contract {
       abi,
       address: contract_address,
       providerOrAccount: account,
-      classHash
+      classHash,
+      parseRequest: params.parseRequest,
+      parseResponse: params.parseResponse,
+      parsingStrategy: params.parsingStrategy
     });
   }
 };
@@ -10394,19 +12070,33 @@ function units(amount, simbol = "fri") {
 }
 var export_TypedDataRevision = api_exports.TypedDataRevision;
 export {
+  AbiParser1,
+  AbiParser2,
+  AbiParserInterface,
   Account,
   AccountInterface,
   BatchClient,
   BlockStatus,
   BlockTag,
+  CairoByteArray,
   CairoCustomEnum,
   CairoFixedArray,
+  CairoInt128,
+  CairoInt16,
+  CairoInt32,
+  CairoInt64,
+  CairoInt8,
   CairoOption,
   CairoOptionVariant,
   CairoResult,
   CairoResultVariant,
+  CairoUint128,
+  CairoUint16,
   CairoUint256,
   CairoUint512,
+  CairoUint64,
+  CairoUint8,
+  CairoUint96,
   CallData,
   Contract,
   ContractInterface,
@@ -10422,6 +12112,7 @@ export {
   ETransactionVersion3,
   EntryPointType,
   EthSigner,
+  Int,
   LedgerSigner111 as LedgerSigner,
   LedgerSigner111,
   LedgerSigner221,
@@ -10475,6 +12166,8 @@ export {
   config,
   constants_exports as constants,
   contractClassResponseToLegacyCompiledContract,
+  createAbiParser,
+  createTransactionReceipt,
   defaultDeployer,
   defaultPaymaster,
   defaultProvider,
@@ -10483,6 +12176,8 @@ export {
   eth_exports as eth,
   events_exports as events,
   extractContractHashes,
+  fastParsingStrategy,
+  getAbiVersion,
   getChecksumAddress,
   getGasPrices,
   getLedgerPathBuffer111 as getLedgerPathBuffer,
@@ -10490,7 +12185,9 @@ export {
   getLedgerPathBuffer221,
   getTipStatsFromBlocks,
   hash_exports as hash,
+  hdParsingStrategy,
   isAccount,
+  isNoConstructorValid,
   isPendingBlock,
   isPendingStateUpdate,
   isPendingTransaction,