starknet 6.9.0 → 6.10.1

package/dist/index.global.js

@@ -10655,7 +10655,7 @@ var starknet = (() => {
       function isString2(data) {
         return typeof data === "string" || data instanceof String;
       }
-      function isObject2(data) {
+      function isObject3(data) {
         return toString.call(data) === "[object Object]";
       }
       function isInstanceStrict(data, prototype) {
@@ -10673,7 +10673,7 @@ var starknet = (() => {
           options = cb;
           cb = null;
         }
-        if (!isObject2(options))
+        if (!isObject3(options))
           options = { Error: "Failed Check" };
         if (!bool) {
           if (cb) {
@@ -10694,7 +10694,7 @@ var starknet = (() => {
       exports.isDate = isDate;
       exports.isEmptyString = isEmptyString;
       exports.isString = isString2;
-      exports.isObject = isObject2;
+      exports.isObject = isObject3;
       exports.validate = validate;
     }
   });
@@ -12699,7 +12699,9 @@ var starknet = (() => {
     RPC: () => api_exports2,
     RPC06: () => rpc_0_6_exports,
     RPC07: () => rpc_0_7_exports,
+    RPCResponseParser: () => RPCResponseParser,
     ReceiptTx: () => ReceiptTx,
+    ResponseParser: () => ResponseParser,
     RpcChannel: () => RpcChannel2,
     RpcProvider: () => RpcProvider2,
     Signer: () => Signer,
@@ -12746,7 +12748,6 @@ var starknet = (() => {
     num: () => num_exports,
     number: () => number3,
     parseCalldataField: () => parseCalldataField,
-    parseUDCEvent: () => parseUDCEvent,
     provider: () => provider_exports,
     selector: () => selector_exports,
     shortString: () => shortString_exports,
@@ -12770,6 +12771,7 @@ var starknet = (() => {
     ADDR_BOUND: () => ADDR_BOUND,
     API_VERSION: () => API_VERSION,
     BaseUrl: () => BaseUrl,
+    FeeMarginPercentage: () => FeeMarginPercentage,
     IS_BROWSER: () => IS_BROWSER,
     MASK_250: () => MASK_250,
     MAX_STORAGE_ITEM_SIZE: () => MAX_STORAGE_ITEM_SIZE,
@@ -12785,8 +12787,7 @@ var starknet = (() => {
     TRANSACTION_VERSION: () => ETransactionVersion4,
     TransactionHashPrefix: () => TransactionHashPrefix,
     UDC: () => UDC,
-    ZERO: () => ZERO,
-    feeMarginPercentage: () => feeMarginPercentage
+    ZERO: () => ZERO
   });
 
   // src/types/api/index.ts
@@ -12842,76 +12843,65 @@ var starknet = (() => {
   var components_exports = {};
 
   // src/types/api/rpcspec_0_6/nonspec.ts
-  var ETransactionType = /* @__PURE__ */ ((ETransactionType3) => {
-    ETransactionType3["DECLARE"] = "DECLARE";
-    ETransactionType3["DEPLOY"] = "DEPLOY";
-    ETransactionType3["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-    ETransactionType3["INVOKE"] = "INVOKE";
-    ETransactionType3["L1_HANDLER"] = "L1_HANDLER";
-    return ETransactionType3;
-  })(ETransactionType || {});
-  var ESimulationFlag = /* @__PURE__ */ ((ESimulationFlag3) => {
-    ESimulationFlag3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-    ESimulationFlag3["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
-    return ESimulationFlag3;
-  })(ESimulationFlag || {});
-  var ETransactionStatus = /* @__PURE__ */ ((ETransactionStatus3) => {
-    ETransactionStatus3["RECEIVED"] = "RECEIVED";
-    ETransactionStatus3["REJECTED"] = "REJECTED";
-    ETransactionStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    ETransactionStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    return ETransactionStatus3;
-  })(ETransactionStatus || {});
-  var ETransactionFinalityStatus = /* @__PURE__ */ ((ETransactionFinalityStatus3) => {
-    ETransactionFinalityStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    ETransactionFinalityStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    return ETransactionFinalityStatus3;
-  })(ETransactionFinalityStatus || {});
-  var ETransactionExecutionStatus = /* @__PURE__ */ ((ETransactionExecutionStatus3) => {
-    ETransactionExecutionStatus3["SUCCEEDED"] = "SUCCEEDED";
-    ETransactionExecutionStatus3["REVERTED"] = "REVERTED";
-    return ETransactionExecutionStatus3;
-  })(ETransactionExecutionStatus || {});
-  var EBlockTag = /* @__PURE__ */ ((EBlockTag3) => {
-    EBlockTag3["LATEST"] = "latest";
-    EBlockTag3["PENDING"] = "pending";
-    return EBlockTag3;
-  })(EBlockTag || {});
-  var EDataAvailabilityMode = /* @__PURE__ */ ((EDataAvailabilityMode3) => {
-    EDataAvailabilityMode3["L1"] = "L1";
-    EDataAvailabilityMode3["L2"] = "L2";
-    return EDataAvailabilityMode3;
-  })(EDataAvailabilityMode || {});
-  var EDAMode = /* @__PURE__ */ ((EDAMode4) => {
-    EDAMode4[EDAMode4["L1"] = 0] = "L1";
-    EDAMode4[EDAMode4["L2"] = 1] = "L2";
-    return EDAMode4;
-  })(EDAMode || {});
-  var ETransactionVersion = /* @__PURE__ */ ((ETransactionVersion5) => {
-    ETransactionVersion5["V0"] = "0x0";
-    ETransactionVersion5["V1"] = "0x1";
-    ETransactionVersion5["V2"] = "0x2";
-    ETransactionVersion5["V3"] = "0x3";
-    ETransactionVersion5["F0"] = "0x100000000000000000000000000000000";
-    ETransactionVersion5["F1"] = "0x100000000000000000000000000000001";
-    ETransactionVersion5["F2"] = "0x100000000000000000000000000000002";
-    ETransactionVersion5["F3"] = "0x100000000000000000000000000000003";
-    return ETransactionVersion5;
-  })(ETransactionVersion || {});
-  var ETransactionVersion2 = /* @__PURE__ */ ((ETransactionVersion24) => {
-    ETransactionVersion24["V0"] = "0x0";
-    ETransactionVersion24["V1"] = "0x1";
-    ETransactionVersion24["V2"] = "0x2";
-    ETransactionVersion24["F0"] = "0x100000000000000000000000000000000";
-    ETransactionVersion24["F1"] = "0x100000000000000000000000000000001";
-    ETransactionVersion24["F2"] = "0x100000000000000000000000000000002";
-    return ETransactionVersion24;
-  })(ETransactionVersion2 || {});
-  var ETransactionVersion3 = /* @__PURE__ */ ((ETransactionVersion34) => {
-    ETransactionVersion34["V3"] = "0x3";
-    ETransactionVersion34["F3"] = "0x100000000000000000000000000000003";
-    return ETransactionVersion34;
-  })(ETransactionVersion3 || {});
+  var ETransactionType = {
+    DECLARE: "DECLARE",
+    DEPLOY: "DEPLOY",
+    DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
+    INVOKE: "INVOKE",
+    L1_HANDLER: "L1_HANDLER"
+  };
+  var ESimulationFlag = {
+    SKIP_VALIDATE: "SKIP_VALIDATE",
+    SKIP_FEE_CHARGE: "SKIP_FEE_CHARGE"
+  };
+  var ETransactionStatus = {
+    RECEIVED: "RECEIVED",
+    REJECTED: "REJECTED",
+    ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+    ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+  };
+  var ETransactionFinalityStatus = {
+    ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+    ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+  };
+  var ETransactionExecutionStatus = {
+    SUCCEEDED: "SUCCEEDED",
+    REVERTED: "REVERTED"
+  };
+  var EBlockTag = {
+    PENDING: "pending",
+    LATEST: "latest"
+  };
+  var EDataAvailabilityMode = {
+    L1: "L1",
+    L2: "L2"
+  };
+  var EDAMode = {
+    L1: 0,
+    L2: 1
+  };
+  var ETransactionVersion = {
+    V0: "0x0",
+    V1: "0x1",
+    V2: "0x2",
+    V3: "0x3",
+    F0: "0x100000000000000000000000000000000",
+    F1: "0x100000000000000000000000000000001",
+    F2: "0x100000000000000000000000000000002",
+    F3: "0x100000000000000000000000000000003"
+  };
+  var ETransactionVersion2 = {
+    V0: "0x0",
+    V1: "0x1",
+    V2: "0x2",
+    F0: "0x100000000000000000000000000000000",
+    F1: "0x100000000000000000000000000000001",
+    F2: "0x100000000000000000000000000000002"
+  };
+  var ETransactionVersion3 = {
+    V3: "0x3",
+    F3: "0x100000000000000000000000000000003"
+  };
 
   // node_modules/starknet-types-07/dist/esm/index.js
   var esm_exports = {};
@@ -12960,76 +12950,65 @@ var starknet = (() => {
   var components_exports2 = {};
 
   // node_modules/starknet-types-07/dist/esm/api/nonspec.js
-  var ETransactionType2;
-  (function(ETransactionType3) {
-    ETransactionType3["DECLARE"] = "DECLARE";
-    ETransactionType3["DEPLOY"] = "DEPLOY";
-    ETransactionType3["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-    ETransactionType3["INVOKE"] = "INVOKE";
-    ETransactionType3["L1_HANDLER"] = "L1_HANDLER";
-  })(ETransactionType2 || (ETransactionType2 = {}));
-  var ESimulationFlag2;
-  (function(ESimulationFlag3) {
-    ESimulationFlag3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-    ESimulationFlag3["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
-  })(ESimulationFlag2 || (ESimulationFlag2 = {}));
-  var ETransactionStatus2;
-  (function(ETransactionStatus3) {
-    ETransactionStatus3["RECEIVED"] = "RECEIVED";
-    ETransactionStatus3["REJECTED"] = "REJECTED";
-    ETransactionStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    ETransactionStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  })(ETransactionStatus2 || (ETransactionStatus2 = {}));
-  var ETransactionFinalityStatus2;
-  (function(ETransactionFinalityStatus3) {
-    ETransactionFinalityStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    ETransactionFinalityStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  })(ETransactionFinalityStatus2 || (ETransactionFinalityStatus2 = {}));
-  var ETransactionExecutionStatus2;
-  (function(ETransactionExecutionStatus3) {
-    ETransactionExecutionStatus3["SUCCEEDED"] = "SUCCEEDED";
-    ETransactionExecutionStatus3["REVERTED"] = "REVERTED";
-  })(ETransactionExecutionStatus2 || (ETransactionExecutionStatus2 = {}));
-  var EBlockTag2;
-  (function(EBlockTag3) {
-    EBlockTag3["LATEST"] = "latest";
-    EBlockTag3["PENDING"] = "pending";
-  })(EBlockTag2 || (EBlockTag2 = {}));
-  var EDataAvailabilityMode2;
-  (function(EDataAvailabilityMode3) {
-    EDataAvailabilityMode3["L1"] = "L1";
-    EDataAvailabilityMode3["L2"] = "L2";
-  })(EDataAvailabilityMode2 || (EDataAvailabilityMode2 = {}));
-  var EDAMode2;
-  (function(EDAMode4) {
-    EDAMode4[EDAMode4["L1"] = 0] = "L1";
-    EDAMode4[EDAMode4["L2"] = 1] = "L2";
-  })(EDAMode2 || (EDAMode2 = {}));
-  var ETransactionVersion4;
-  (function(ETransactionVersion5) {
-    ETransactionVersion5["V0"] = "0x0";
-    ETransactionVersion5["V1"] = "0x1";
-    ETransactionVersion5["V2"] = "0x2";
-    ETransactionVersion5["V3"] = "0x3";
-    ETransactionVersion5["F0"] = "0x100000000000000000000000000000000";
-    ETransactionVersion5["F1"] = "0x100000000000000000000000000000001";
-    ETransactionVersion5["F2"] = "0x100000000000000000000000000000002";
-    ETransactionVersion5["F3"] = "0x100000000000000000000000000000003";
-  })(ETransactionVersion4 || (ETransactionVersion4 = {}));
-  var ETransactionVersion22;
-  (function(ETransactionVersion24) {
-    ETransactionVersion24["V0"] = "0x0";
-    ETransactionVersion24["V1"] = "0x1";
-    ETransactionVersion24["V2"] = "0x2";
-    ETransactionVersion24["F0"] = "0x100000000000000000000000000000000";
-    ETransactionVersion24["F1"] = "0x100000000000000000000000000000001";
-    ETransactionVersion24["F2"] = "0x100000000000000000000000000000002";
-  })(ETransactionVersion22 || (ETransactionVersion22 = {}));
-  var ETransactionVersion32;
-  (function(ETransactionVersion34) {
-    ETransactionVersion34["V3"] = "0x3";
-    ETransactionVersion34["F3"] = "0x100000000000000000000000000000003";
-  })(ETransactionVersion32 || (ETransactionVersion32 = {}));
+  var ETransactionType2 = {
+    DECLARE: "DECLARE",
+    DEPLOY: "DEPLOY",
+    DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
+    INVOKE: "INVOKE",
+    L1_HANDLER: "L1_HANDLER"
+  };
+  var ESimulationFlag2 = {
+    SKIP_VALIDATE: "SKIP_VALIDATE",
+    SKIP_FEE_CHARGE: "SKIP_FEE_CHARGE"
+  };
+  var ETransactionStatus2 = {
+    RECEIVED: "RECEIVED",
+    REJECTED: "REJECTED",
+    ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+    ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+  };
+  var ETransactionFinalityStatus2 = {
+    ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+    ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+  };
+  var ETransactionExecutionStatus2 = {
+    SUCCEEDED: "SUCCEEDED",
+    REVERTED: "REVERTED"
+  };
+  var EBlockTag2 = {
+    LATEST: "latest",
+    PENDING: "pending"
+  };
+  var EDataAvailabilityMode2 = {
+    L1: "L1",
+    L2: "L2"
+  };
+  var EDAMode2 = {
+    L1: 0,
+    L2: 1
+  };
+  var ETransactionVersion4 = {
+    V0: "0x0",
+    V1: "0x1",
+    V2: "0x2",
+    V3: "0x3",
+    F0: "0x100000000000000000000000000000000",
+    F1: "0x100000000000000000000000000000001",
+    F2: "0x100000000000000000000000000000002",
+    F3: "0x100000000000000000000000000000003"
+  };
+  var ETransactionVersion22 = {
+    V0: "0x0",
+    V1: "0x1",
+    V2: "0x2",
+    F0: "0x100000000000000000000000000000000",
+    F1: "0x100000000000000000000000000000001",
+    F2: "0x100000000000000000000000000000002"
+  };
+  var ETransactionVersion32 = {
+    V3: "0x3",
+    F3: "0x100000000000000000000000000000003"
+  };
 
   // node_modules/starknet-types-07/dist/esm/wallet-api/index.js
   var wallet_api_exports = {};
@@ -13039,17 +13018,15 @@ var starknet = (() => {
   });
 
   // node_modules/starknet-types-07/dist/esm/wallet-api/constants.js
-  var Permission;
-  (function(Permission2) {
-    Permission2["Accounts"] = "accounts";
-  })(Permission || (Permission = {}));
+  var Permission = {
+    ACCOUNTS: "accounts"
+  };
 
   // node_modules/starknet-types-07/dist/esm/wallet-api/typedData.js
-  var TypedDataRevision;
-  (function(TypedDataRevision2) {
-    TypedDataRevision2["Active"] = "1";
-    TypedDataRevision2["Legacy"] = "0";
-  })(TypedDataRevision || (TypedDataRevision = {}));
+  var TypedDataRevision = {
+    ACTIVE: "1",
+    LEGACY: "0"
+  };
 
   // src/utils/encode.ts
   var encode_exports = {};
@@ -13296,35 +13273,37 @@ var starknet = (() => {
   var RANGE_FELT = range(ZERO, PRIME - 1n);
   var RANGE_I128 = range(-(2n ** 127n), 2n ** 127n - 1n);
   var RANGE_U128 = range(ZERO, 2n ** 128n - 1n);
-  var BaseUrl = /* @__PURE__ */ ((BaseUrl2) => {
-    BaseUrl2["SN_MAIN"] = "https://alpha-mainnet.starknet.io";
-    BaseUrl2["SN_SEPOLIA"] = "https://alpha-sepolia.starknet.io";
-    return BaseUrl2;
-  })(BaseUrl || {});
-  var NetworkName = /* @__PURE__ */ ((NetworkName2) => {
-    NetworkName2["SN_MAIN"] = "SN_MAIN";
-    NetworkName2["SN_SEPOLIA"] = "SN_SEPOLIA";
-    return NetworkName2;
-  })(NetworkName || {});
-  var StarknetChainId = /* @__PURE__ */ ((StarknetChainId6) => {
-    StarknetChainId6["SN_MAIN"] = "0x534e5f4d41494e";
-    StarknetChainId6["SN_SEPOLIA"] = "0x534e5f5345504f4c4941";
-    return StarknetChainId6;
-  })(StarknetChainId || {});
-  var TransactionHashPrefix = /* @__PURE__ */ ((TransactionHashPrefix2) => {
-    TransactionHashPrefix2["DECLARE"] = "0x6465636c617265";
-    TransactionHashPrefix2["DEPLOY"] = "0x6465706c6f79";
-    TransactionHashPrefix2["DEPLOY_ACCOUNT"] = "0x6465706c6f795f6163636f756e74";
-    TransactionHashPrefix2["INVOKE"] = "0x696e766f6b65";
-    TransactionHashPrefix2["L1_HANDLER"] = "0x6c315f68616e646c6572";
-    return TransactionHashPrefix2;
-  })(TransactionHashPrefix || {});
-  var feeMarginPercentage = /* @__PURE__ */ ((feeMarginPercentage2) => {
-    feeMarginPercentage2[feeMarginPercentage2["L1_BOUND_MAX_AMOUNT"] = 50] = "L1_BOUND_MAX_AMOUNT";
-    feeMarginPercentage2[feeMarginPercentage2["L1_BOUND_MAX_PRICE_PER_UNIT"] = 50] = "L1_BOUND_MAX_PRICE_PER_UNIT";
-    feeMarginPercentage2[feeMarginPercentage2["MAX_FEE"] = 50] = "MAX_FEE";
-    return feeMarginPercentage2;
-  })(feeMarginPercentage || {});
+  var BaseUrl = {
+    SN_MAIN: "https://alpha-mainnet.starknet.io",
+    SN_SEPOLIA: "https://alpha-sepolia.starknet.io"
+  };
+  var NetworkName = {
+    SN_MAIN: "SN_MAIN",
+    SN_SEPOLIA: "SN_SEPOLIA"
+  };
+  var StarknetChainId = {
+    SN_MAIN: "0x534e5f4d41494e",
+    // encodeShortString('SN_MAIN'),
+    SN_SEPOLIA: "0x534e5f5345504f4c4941"
+    // encodeShortString('SN_SEPOLIA')
+  };
+  var TransactionHashPrefix = {
+    DECLARE: "0x6465636c617265",
+    // encodeShortString('declare'),
+    DEPLOY: "0x6465706c6f79",
+    // encodeShortString('deploy'),
+    DEPLOY_ACCOUNT: "0x6465706c6f795f6163636f756e74",
+    // encodeShortString('deploy_account'),
+    INVOKE: "0x696e766f6b65",
+    // encodeShortString('invoke'),
+    L1_HANDLER: "0x6c315f68616e646c6572"
+    // encodeShortString('l1_handler'),
+  };
+  var FeeMarginPercentage = {
+    L1_BOUND_MAX_AMOUNT: 50,
+    L1_BOUND_MAX_PRICE_PER_UNIT: 50,
+    MAX_FEE: 50
+  };
   var UDC = {
     ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf",
     ENTRYPOINT: "deployContract"
@@ -13951,79 +13930,71 @@ var starknet = (() => {
   });
 
   // src/types/calldata.ts
-  var ValidateType = /* @__PURE__ */ ((ValidateType2) => {
-    ValidateType2["DEPLOY"] = "DEPLOY";
-    ValidateType2["CALL"] = "CALL";
-    ValidateType2["INVOKE"] = "INVOKE";
-    return ValidateType2;
-  })(ValidateType || {});
-  var Uint = /* @__PURE__ */ ((Uint2) => {
-    Uint2["u8"] = "core::integer::u8";
-    Uint2["u16"] = "core::integer::u16";
-    Uint2["u32"] = "core::integer::u32";
-    Uint2["u64"] = "core::integer::u64";
-    Uint2["u128"] = "core::integer::u128";
-    Uint2["u256"] = "core::integer::u256";
-    Uint2["u512"] = "core::integer::u512";
-    return Uint2;
-  })(Uint || {});
-  var Literal = /* @__PURE__ */ ((Literal2) => {
-    Literal2["ClassHash"] = "core::starknet::class_hash::ClassHash";
-    Literal2["ContractAddress"] = "core::starknet::contract_address::ContractAddress";
-    Literal2["Secp256k1Point"] = "core::starknet::secp256k1::Secp256k1Point";
-    return Literal2;
-  })(Literal || {});
+  var ValidateType = {
+    DEPLOY: "DEPLOY",
+    CALL: "CALL",
+    INVOKE: "INVOKE"
+  };
+  var Uint = {
+    u8: "core::integer::u8",
+    u16: "core::integer::u16",
+    u32: "core::integer::u32",
+    u64: "core::integer::u64",
+    u128: "core::integer::u128",
+    u256: "core::integer::u256",
+    // This one is struct
+    u512: "core::integer::u512"
+    // This one is struct
+  };
+  var Literal = {
+    ClassHash: "core::starknet::class_hash::ClassHash",
+    ContractAddress: "core::starknet::contract_address::ContractAddress",
+    Secp256k1Point: "core::starknet::secp256k1::Secp256k1Point"
+  };
 
   // src/types/lib/contract/index.ts
-  var EntryPointType = /* @__PURE__ */ ((EntryPointType2) => {
-    EntryPointType2["EXTERNAL"] = "EXTERNAL";
-    EntryPointType2["L1_HANDLER"] = "L1_HANDLER";
-    EntryPointType2["CONSTRUCTOR"] = "CONSTRUCTOR";
-    return EntryPointType2;
-  })(EntryPointType || {});
+  var EntryPointType = {
+    EXTERNAL: "EXTERNAL",
+    L1_HANDLER: "L1_HANDLER",
+    CONSTRUCTOR: "CONSTRUCTOR"
+  };
 
   // src/types/lib/index.ts
-  var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
-    TransactionType2["DECLARE"] = "DECLARE";
-    TransactionType2["DEPLOY"] = "DEPLOY";
-    TransactionType2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-    TransactionType2["INVOKE"] = "INVOKE_FUNCTION";
-    return TransactionType2;
-  })(TransactionType || {});
-  var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
-    TransactionStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
-    TransactionStatus2["RECEIVED"] = "RECEIVED";
-    TransactionStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    TransactionStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    TransactionStatus2["REJECTED"] = "REJECTED";
-    TransactionStatus2["REVERTED"] = "REVERTED";
-    return TransactionStatus2;
-  })(TransactionStatus || {});
-  var TransactionFinalityStatus = /* @__PURE__ */ ((TransactionFinalityStatus2) => {
-    TransactionFinalityStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
-    TransactionFinalityStatus2["RECEIVED"] = "RECEIVED";
-    TransactionFinalityStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    TransactionFinalityStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    return TransactionFinalityStatus2;
-  })(TransactionFinalityStatus || {});
-  var TransactionExecutionStatus = /* @__PURE__ */ ((TransactionExecutionStatus2) => {
-    TransactionExecutionStatus2["REJECTED"] = "REJECTED";
-    TransactionExecutionStatus2["REVERTED"] = "REVERTED";
-    TransactionExecutionStatus2["SUCCEEDED"] = "SUCCEEDED";
-    return TransactionExecutionStatus2;
-  })(TransactionExecutionStatus || {});
-  var BlockStatus = /* @__PURE__ */ ((BlockStatus2) => {
-    BlockStatus2["PENDING"] = "PENDING";
-    BlockStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    BlockStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    BlockStatus2["REJECTED"] = "REJECTED";
-    return BlockStatus2;
-  })(BlockStatus || {});
-  var BlockTag = /* @__PURE__ */ ((BlockTag2) => {
-    BlockTag2["pending"] = "pending";
-    BlockTag2["latest"] = "latest";
-    return BlockTag2;
-  })(BlockTag || {});
+  var TransactionType = {
+    DECLARE: "DECLARE",
+    DEPLOY: "DEPLOY",
+    DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
+    INVOKE: "INVOKE_FUNCTION"
+  };
+  var TransactionStatus = {
+    NOT_RECEIVED: "NOT_RECEIVED",
+    RECEIVED: "RECEIVED",
+    ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+    ACCEPTED_ON_L1: "ACCEPTED_ON_L1",
+    REJECTED: "REJECTED",
+    REVERTED: "REVERTED"
+  };
+  var TransactionFinalityStatus = {
+    NOT_RECEIVED: "NOT_RECEIVED",
+    RECEIVED: "RECEIVED",
+    ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+    ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+  };
+  var TransactionExecutionStatus = {
+    REJECTED: "REJECTED",
+    REVERTED: "REVERTED",
+    SUCCEEDED: "SUCCEEDED"
+  };
+  var BlockStatus = {
+    PENDING: "PENDING",
+    ACCEPTED_ON_L1: "ACCEPTED_ON_L1",
+    ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+    REJECTED: "REJECTED"
+  };
+  var BlockTag = {
+    PENDING: "pending",
+    LATEST: "latest"
+  };
 
   // src/utils/assert.ts
   function assert(condition, message) {
@@ -14065,18 +14036,19 @@ var starknet = (() => {
   function isBigInt(value) {
     return typeof value === "bigint";
   }
-  function toHex(number4) {
-    return addHexPrefix(toBigInt(number4).toString(16));
+  function toHex(value) {
+    return addHexPrefix(toBigInt(value).toString(16));
   }
   var toHexString = toHex;
   function toStorageKey(number4) {
-    const res = addHexPrefix(toBigInt(number4).toString(16).padStart(64, "0"));
-    return res;
+    return addHexPrefix(toBigInt(number4).toString(16).padStart(64, "0"));
   }
   function hexToDecimalString(hex) {
     return BigInt(addHexPrefix(hex)).toString(10);
   }
-  var cleanHex = (hex) => hex.toLowerCase().replace(/^(0x)0+/, "$1");
+  function cleanHex(hex) {
+    return hex.toLowerCase().replace(/^(0x)0+/, "$1");
+  }
   function assertInRange(input, lowerBound, upperBound, inputName = "") {
     const messageSuffix = inputName === "" ? "invalid length" : `invalid ${inputName} length`;
     const inputBigInt = BigInt(input);
@@ -14087,39 +14059,43 @@ var starknet = (() => {
       `Message not signable, ${messageSuffix}.`
     );
   }
-  function bigNumberishArrayToDecimalStringArray(rawCalldata) {
-    return rawCalldata.map((x) => toBigInt(x).toString(10));
+  function bigNumberishArrayToDecimalStringArray(data) {
+    return data.map((x) => toBigInt(x).toString(10));
   }
-  function bigNumberishArrayToHexadecimalStringArray(rawCalldata) {
-    return rawCalldata.map((x) => toHex(x));
+  function bigNumberishArrayToHexadecimalStringArray(data) {
+    return data.map((x) => toHex(x));
   }
-  var isStringWholeNumber = (value) => /^\d+$/.test(value);
-  function getDecimalString(value) {
-    if (isHex(value)) {
-      return hexToDecimalString(value);
+  function isStringWholeNumber(str) {
+    return /^\d+$/.test(str);
+  }
+  function getDecimalString(str) {
+    if (isHex(str)) {
+      return hexToDecimalString(str);
     }
-    if (isStringWholeNumber(value)) {
-      return value;
+    if (isStringWholeNumber(str)) {
+      return str;
     }
-    throw new Error(`${value} need to be hex-string or whole-number-string`);
+    throw new Error(`${str} needs to be a hex-string or whole-number-string`);
   }
-  function getHexString(value) {
-    if (isHex(value)) {
-      return value;
+  function getHexString(str) {
+    if (isHex(str)) {
+      return str;
     }
-    if (isStringWholeNumber(value)) {
-      return toHexString(value);
+    if (isStringWholeNumber(str)) {
+      return toHexString(str);
     }
-    throw new Error(`${value} need to be hex-string or whole-number-string`);
+    throw new Error(`${str} needs to be a hex-string or whole-number-string`);
   }
-  function getHexStringArray(value) {
-    return value.map((el) => getHexString(el));
+  function getHexStringArray(array) {
+    return array.map(getHexString);
   }
-  var toCairoBool = (value) => (+value).toString();
-  function hexToBytes2(value) {
-    if (!isHex(value))
-      throw new Error(`${value} need to be a hex-string`);
-    let adaptedValue = removeHexPrefix(value);
+  function toCairoBool(value) {
+    return (+value).toString();
+  }
+  function hexToBytes2(str) {
+    if (!isHex(str))
+      throw new Error(`${str} needs to be a hex-string`);
+    let adaptedValue = removeHexPrefix(str);
     if (adaptedValue.length % 2 !== 0) {
       adaptedValue = `0${adaptedValue}`;
     }
@@ -14136,7 +14112,7 @@ var starknet = (() => {
     return typeof value === "boolean";
   }
 
-  // src/utils/selector.ts
+  // src/utils/hash/selector.ts
   var selector_exports = {};
   __export(selector_exports, {
     getSelector: () => getSelector,
@@ -16559,7 +16535,7 @@ var starknet = (() => {
     return state[0];
   }
 
-  // src/utils/selector.ts
+  // src/utils/hash/selector.ts
   function keccakBn(value) {
     const hexWithoutPrefix = removeHexPrefix(toHex(BigInt(value)));
     const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
@@ -16683,6 +16659,7 @@ var starknet = (() => {
     isTypeFelt: () => isTypeFelt,
     isTypeLiteral: () => isTypeLiteral,
     isTypeNamedTuple: () => isTypeNamedTuple,
+    isTypeNonZero: () => isTypeNonZero,
     isTypeOption: () => isTypeOption,
     isTypeResult: () => isTypeResult,
     isTypeSecp256k1Point: () => isTypeSecp256k1Point,
@@ -16984,6 +16961,9 @@ var starknet = (() => {
     }
     return cairo === "1";
   }
+  function isTypeNonZero(type) {
+    return type.startsWith("core::zeroable::NonZero::");
+  }
   function getAbiContractVersion(abi) {
     if (abi.find((it) => it.type === "interface")) {
       return { cairo: "1", compiler: "2" };
@@ -17064,19 +17044,18 @@ var starknet = (() => {
   };
 
   // src/utils/calldata/enum/CairoOption.ts
-  var CairoOptionVariant = /* @__PURE__ */ ((CairoOptionVariant2) => {
-    CairoOptionVariant2[CairoOptionVariant2["Some"] = 0] = "Some";
-    CairoOptionVariant2[CairoOptionVariant2["None"] = 1] = "None";
-    return CairoOptionVariant2;
-  })(CairoOptionVariant || {});
+  var CairoOptionVariant = {
+    Some: 0,
+    None: 1
+  };
   var CairoOption = class {
     Some;
     None;
     constructor(variant, someContent) {
-      if (!(variant in CairoOptionVariant)) {
+      if (!(variant in Object.values(CairoOptionVariant))) {
         throw new Error("Wrong variant : should be CairoOptionVariant.Some or .None.");
       }
-      if (variant === 0 /* Some */) {
+      if (variant === CairoOptionVariant.Some) {
         if (typeof someContent === "undefined") {
           throw new Error(
             'The creation of a Cairo Option with "Some" variant needs a content as input.'
@@ -17117,19 +17096,18 @@ var starknet = (() => {
   };
 
   // src/utils/calldata/enum/CairoResult.ts
-  var CairoResultVariant = /* @__PURE__ */ ((CairoResultVariant2) => {
-    CairoResultVariant2[CairoResultVariant2["Ok"] = 0] = "Ok";
-    CairoResultVariant2[CairoResultVariant2["Err"] = 1] = "Err";
-    return CairoResultVariant2;
-  })(CairoResultVariant || {});
+  var CairoResultVariant = {
+    Ok: 0,
+    Err: 1
+  };
   var CairoResult = class {
     Ok;
     Err;
     constructor(variant, resultContent) {
-      if (!(variant in CairoResultVariant)) {
+      if (!(variant in Object.values(CairoResultVariant))) {
         throw new Error("Wrong variant : should be CairoResultVariant.Ok or .Err.");
       }
-      if (variant === 0 /* Ok */) {
+      if (variant === CairoResultVariant.Ok) {
         this.Ok = resultContent;
         this.Err = void 0;
       } else {
@@ -17435,6 +17413,9 @@ var starknet = (() => {
       if (isTypeEthAddress(abiType)) {
         return unorderedItem;
       }
+      if (isTypeNonZero(abiType)) {
+        return unorderedItem;
+      }
       if (isTypeByteArray(abiType)) {
         return unorderedItem;
       }
@@ -17517,12 +17498,12 @@ var starknet = (() => {
         );
         if (unorderedResult.isOk()) {
           return new CairoResult(
-            0 /* Ok */,
+            CairoResultVariant.Ok,
             orderInput(unorderedObject2.unwrap(), resultOkType)
           );
         }
         return new CairoResult(
-          1 /* Err */,
+          CairoResultVariant.Err,
           orderInput(unorderedObject2.unwrap(), resultErrType)
         );
       }
@@ -17534,11 +17515,11 @@ var starknet = (() => {
         );
         if (unorderedOption.isSome()) {
           return new CairoOption(
-            0 /* Some */,
+            CairoOptionVariant.Some,
             orderInput(unorderedOption.unwrap(), resultSomeType)
           );
         }
-        return new CairoOption(1 /* None */, {});
+        return new CairoOption(CairoOptionVariant.None, {});
       }
       const unorderedCustomEnum = unorderedObject2;
       const variants = Object.entries(unorderedCustomEnum.variant);
@@ -17674,7 +17655,7 @@ var starknet = (() => {
           }
           const typeVariantSome = listTypeVariant2.type;
           if (typeVariantSome === "()") {
-            return 0 /* Some */.toString();
+            return CairoOptionVariant.Some.toString();
           }
           const parsedParameter2 = parseCalldataValue(
             myOption.unwrap(),
@@ -17683,11 +17664,11 @@ var starknet = (() => {
             enums
           );
           if (Array.isArray(parsedParameter2)) {
-            return [0 /* Some */.toString(), ...parsedParameter2];
+            return [CairoOptionVariant.Some.toString(), ...parsedParameter2];
           }
-          return [0 /* Some */.toString(), parsedParameter2];
+          return [CairoOptionVariant.Some.toString(), parsedParameter2];
         }
-        return 1 /* None */.toString();
+        return CairoOptionVariant.None.toString();
       }
       if (isTypeResult(type)) {
         const myResult = element;
@@ -17698,7 +17679,7 @@ var starknet = (() => {
           }
           const typeVariantOk = listTypeVariant3.type;
           if (typeVariantOk === "()") {
-            return 0 /* Ok */.toString();
+            return CairoResultVariant.Ok.toString();
           }
           const parsedParameter3 = parseCalldataValue(
             myResult.unwrap(),
@@ -17707,9 +17688,9 @@ var starknet = (() => {
             enums
           );
           if (Array.isArray(parsedParameter3)) {
-            return [0 /* Ok */.toString(), ...parsedParameter3];
+            return [CairoResultVariant.Ok.toString(), ...parsedParameter3];
           }
-          return [0 /* Ok */.toString(), parsedParameter3];
+          return [CairoResultVariant.Ok.toString(), parsedParameter3];
         }
         const listTypeVariant2 = variants.find((variant) => variant.name === "Err");
         if (typeof listTypeVariant2 === "undefined") {
@@ -17717,13 +17698,13 @@ var starknet = (() => {
         }
         const typeVariantErr = listTypeVariant2.type;
         if (typeVariantErr === "()") {
-          return 1 /* Err */.toString();
+          return CairoResultVariant.Err.toString();
         }
         const parsedParameter2 = parseCalldataValue(myResult.unwrap(), typeVariantErr, structs, enums);
         if (Array.isArray(parsedParameter2)) {
-          return [1 /* Err */.toString(), ...parsedParameter2];
+          return [CairoResultVariant.Err.toString(), ...parsedParameter2];
         }
-        return [1 /* Err */.toString(), parsedParameter2];
+        return [CairoResultVariant.Err.toString(), parsedParameter2];
       }
       const myEnum = element;
       const activeVariant = myEnum.activeVariant();
@@ -17742,6 +17723,9 @@ var starknet = (() => {
       }
       return [numActiveVariant.toString(), parsedParameter];
     }
+    if (isTypeNonZero(type)) {
+      return parseBaseTypes(getArrayType(type), element);
+    }
     if (typeof element === "object") {
       throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
     }
@@ -17759,6 +17743,8 @@ var starknet = (() => {
           value = splitLongString(value);
         }
         return parseCalldataValue(value, input.type, structs, enums);
+      case isTypeNonZero(type):
+        return parseBaseTypes(getArrayType(type), value);
       case type === "core::starknet::eth_address::EthAddress":
         return parseBaseTypes(type, value);
       case (isTypeStruct(type, structs) || isTypeTuple(type) || CairoUint256.isAbiType(type) || CairoUint256.isAbiType(type)):
@@ -17850,6 +17836,10 @@ var starknet = (() => {
       }
       return parsedDataArr;
     }
+    if (isTypeNonZero(element.type)) {
+      const el = { name: "", type: getArrayType(element.type) };
+      return parseResponseValue(responseIterator, el, structs, enums);
+    }
     if (structs && element.type in structs && structs[element.type]) {
       if (element.type === "core::starknet::eth_address::EthAddress") {
         return parseBaseTypes2(element.type, responseIterator);
@@ -17875,12 +17865,12 @@ var starknet = (() => {
         return acc;
       }, {});
       if (element.type.startsWith("core::option::Option")) {
-        const content = variantNum === 0 /* Some */ ? rawEnum.Some : void 0;
+        const content = variantNum === CairoOptionVariant.Some ? rawEnum.Some : void 0;
         return new CairoOption(variantNum, content);
       }
       if (element.type.startsWith("core::result::Result")) {
         let content;
-        if (variantNum === 0 /* Ok */) {
+        if (variantNum === CairoResultVariant.Ok) {
           content = rawEnum.Ok;
         } else {
           content = rawEnum.Err;
@@ -17941,6 +17931,8 @@ var starknet = (() => {
           }
         }
         return parsedDataArr;
+      case isTypeNonZero(type):
+        return parseResponseValue(responseIterator, output3, structs, enums);
       default:
         return parseBaseTypes2(type, responseIterator);
     }
@@ -17984,70 +17976,70 @@ var starknet = (() => {
     );
     let param;
     switch (input.type) {
-      case "core::integer::u256" /* u256 */:
+      case Uint.u256:
         param = new CairoUint256(parameter).toBigInt();
         break;
-      case "core::integer::u512" /* u512 */:
+      case Uint.u512:
         param = new CairoUint512(parameter).toBigInt();
         break;
       default:
         param = toBigInt(parameter);
     }
     switch (input.type) {
-      case "core::integer::u8" /* u8 */:
+      case Uint.u8:
         assert(
           param >= 0n && param <= 255n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
         );
         break;
-      case "core::integer::u16" /* u16 */:
+      case Uint.u16:
         assert(
           param >= 0n && param <= 65535n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
         );
         break;
-      case "core::integer::u32" /* u32 */:
+      case Uint.u32:
         assert(
           param >= 0n && param <= 4294967295n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
         );
         break;
-      case "core::integer::u64" /* u64 */:
+      case Uint.u64:
         assert(
           param >= 0n && param <= 2n ** 64n - 1n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^64-1]`
         );
         break;
-      case "core::integer::u128" /* u128 */:
+      case Uint.u128:
         assert(
           param >= 0n && param <= 2n ** 128n - 1n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^128-1]`
         );
         break;
-      case "core::integer::u256" /* u256 */:
+      case Uint.u256:
         assert(
           param >= 0n && param <= 2n ** 256n - 1n,
           `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
         );
         break;
-      case "core::integer::u512" /* u512 */:
+      case Uint.u512:
         assert(CairoUint512.is(param), `Validate: arg ${input.name} is ${input.type} 0 - 2^512-1`);
         break;
-      case "core::starknet::class_hash::ClassHash" /* ClassHash */:
+      case Literal.ClassHash:
         assert(
           // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1670
           param >= 0n && param <= 2n ** 252n - 1n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`
         );
         break;
-      case "core::starknet::contract_address::ContractAddress" /* ContractAddress */:
+      case Literal.ContractAddress:
         assert(
           // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1245
           param >= 0n && param <= 2n ** 252n - 1n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`
         );
         break;
-      case "core::starknet::secp256k1::Secp256k1Point" /* Secp256k1Point */: {
+      case Literal.Secp256k1Point: {
         assert(
           param >= 0n && param <= 2n ** 512n - 1n,
           `Validate: arg ${input.name} must be ${input.type} : a 512 bits number.`
@@ -18065,7 +18057,7 @@ var starknet = (() => {
     );
   };
   var validateStruct = (parameter, input, structs) => {
-    if (input.type === "core::integer::u256" /* u256 */ || input.type === "core::integer::u512" /* u512 */) {
+    if (input.type === Uint.u256 || input.type === Uint.u512) {
       validateUint(parameter, input);
       return;
     }
@@ -18157,6 +18149,42 @@ var starknet = (() => {
         );
     }
   };
+  var validateNonZero = (parameter, input) => {
+    const baseType = getArrayType(input.type);
+    assert(
+      isTypeUint(baseType) && baseType !== CairoUint512.abiSelector || isTypeFelt(baseType),
+      `Validate: ${input.name} type is not authorized for NonZero type.`
+    );
+    switch (true) {
+      case isTypeFelt(baseType):
+        validateFelt(parameter, input);
+        assert(
+          BigInt(parameter.toString(10)) > 0,
+          "Validate: value 0 is not authorized in NonZero felt252 type."
+        );
+        break;
+      case isTypeUint(baseType):
+        validateUint(parameter, { name: "", type: baseType });
+        switch (input.type) {
+          case Uint.u256:
+            assert(
+              new CairoUint256(parameter).toBigInt() > 0,
+              "Validate: value 0 is not authorized in NonZero uint256 type."
+            );
+            break;
+          default:
+            assert(
+              toBigInt(parameter) > 0,
+              "Validate: value 0 is not authorized in NonZero uint type."
+            );
+        }
+        break;
+      default:
+        throw new Error(
+          `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
+        );
+    }
+  };
   function validateFields(abiMethod, args, structs, enums) {
     abiMethod.inputs.reduce((acc, input) => {
       const parameter = args[acc];
@@ -18190,6 +18218,9 @@ var starknet = (() => {
         case isTypeTuple(input.type):
           validateTuple(parameter, input);
           break;
+        case isTypeNonZero(input.type):
+          validateNonZero(parameter, input);
+          break;
         default:
           throw new Error(
             `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
@@ -18218,20 +18249,20 @@ var starknet = (() => {
      * @param args ArgsOrCalldata - arguments that are passed to the method
      */
     validate(type, method, args = []) {
-      if (type !== "DEPLOY" /* DEPLOY */) {
+      if (type !== ValidateType.DEPLOY) {
         const invocableFunctionNames = this.abi.filter((abi) => {
           if (abi.type !== "function")
             return false;
           const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
-          return type === "INVOKE" /* INVOKE */ ? !isView : isView;
+          return type === ValidateType.INVOKE ? !isView : isView;
         }).map((abi) => abi.name);
         assert(
           invocableFunctionNames.includes(method),
-          `${type === "INVOKE" /* INVOKE */ ? "invocable" : "viewable"} method not found in abi`
+          `${type === ValidateType.INVOKE ? "invocable" : "viewable"} method not found in abi`
         );
       }
       const abiMethod = this.abi.find(
-        (abi) => type === "DEPLOY" /* DEPLOY */ ? abi.name === method && abi.type === "constructor" : abi.name === method && abi.type === "function"
+        (abi) => type === ValidateType.DEPLOY ? abi.name === method && abi.type === "constructor" : abi.name === method && abi.type === "function"
       );
       if (isNoConstructorValid(method, args, abiMethod)) {
         return;
@@ -18311,14 +18342,14 @@ var starknet = (() => {
               const keys = [...Object.getOwnPropertyNames(value), ...methodsKeys];
               if (keys.includes("isSome") && keys.includes("isNone")) {
                 const myOption = value;
-                const variantNb = myOption.isSome() ? 0 /* Some */ : 1 /* None */;
+                const variantNb = myOption.isSome() ? CairoOptionVariant.Some : CairoOptionVariant.None;
                 if (myOption.isSome())
                   return getEntries({ 0: variantNb, 1: myOption.unwrap() }, `${prefix}${kk}.`);
                 return [[`${prefix}${kk}`, felt(variantNb)]];
               }
               if (keys.includes("isOk") && keys.includes("isErr")) {
                 const myResult = value;
-                const variantNb = myResult.isOk() ? 0 /* Ok */ : 1 /* Err */;
+                const variantNb = myResult.isOk() ? CairoResultVariant.Ok : CairoResultVariant.Err;
                 return getEntries({ 0: variantNb, 1: myResult.unwrap() }, `${prefix}${kk}.`);
               }
               if (keys.includes("variant") && keys.includes("activeVariant")) {
@@ -18469,6 +18500,7 @@ var starknet = (() => {
     computeCompiledClassHash: () => computeCompiledClassHash,
     computeContractClassHash: () => computeContractClassHash,
     computeHashOnElements: () => computeHashOnElements3,
+    computeHintedClassHash: () => computeHintedClassHash,
     computeLegacyContractClassHash: () => computeLegacyContractClassHash,
     computePedersenHash: () => computePedersenHash,
     computePedersenHashOnElements: () => computePedersenHashOnElements,
@@ -19918,7 +19950,7 @@ var starknet = (() => {
   }
   function calculateDeclareTransactionHash(classHash, senderAddress, version, maxFee, chainId, nonce, compiledClassHash) {
     return calculateTransactionHashCommon(
-      "0x6465636c617265" /* DECLARE */,
+      TransactionHashPrefix.DECLARE,
       version,
       senderAddress,
       0,
@@ -19931,7 +19963,7 @@ var starknet = (() => {
   function calculateDeployAccountTransactionHash(contractAddress, classHash, constructorCalldata, salt, version, maxFee, chainId, nonce) {
     const calldata = [classHash, salt, ...constructorCalldata];
     return calculateTransactionHashCommon(
-      "0x6465706c6f795f6163636f756e74" /* DEPLOY_ACCOUNT */,
+      TransactionHashPrefix.DEPLOY_ACCOUNT,
       version,
       contractAddress,
       0,
@@ -19943,7 +19975,7 @@ var starknet = (() => {
   }
   function calculateTransactionHash(contractAddress, version, calldata, maxFee, chainId, nonce) {
     return calculateTransactionHashCommon(
-      "0x696e766f6b65" /* INVOKE */,
+      TransactionHashPrefix.INVOKE,
       version,
       contractAddress,
       0,
@@ -19997,7 +20029,7 @@ var starknet = (() => {
   }
   function calculateDeployAccountTransactionHash2(contractAddress, classHash, compiledConstructorCalldata, salt, version, chainId, nonce, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
     return calculateTransactionHashCommon2(
-      "0x6465706c6f795f6163636f756e74" /* DEPLOY_ACCOUNT */,
+      TransactionHashPrefix.DEPLOY_ACCOUNT,
       version,
       contractAddress,
       chainId,
@@ -20012,7 +20044,7 @@ var starknet = (() => {
   }
   function calculateDeclareTransactionHash2(classHash, compiledClassHash, senderAddress, version, chainId, nonce, accountDeploymentData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
     return calculateTransactionHashCommon2(
-      "0x6465636c617265" /* DECLARE */,
+      TransactionHashPrefix.DECLARE,
       version,
       senderAddress,
       chainId,
@@ -20027,7 +20059,7 @@ var starknet = (() => {
   }
   function calculateInvokeTransactionHash(senderAddress, version, compiledCalldata, chainId, nonce, accountDeploymentData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
     return calculateTransactionHashCommon2(
-      "0x696e766f6b65" /* INVOKE */,
+      TransactionHashPrefix.INVOKE,
       version,
       senderAddress,
       chainId,
@@ -20043,9 +20075,7 @@ var starknet = (() => {
 
   // src/utils/hash/transactionHash/index.ts
   function isV3InvokeTx(args) {
-    return [ETransactionVersion4.V3, ETransactionVersion4.F3].includes(
-      args.version
-    );
+    return [ETransactionVersion4.V3, ETransactionVersion4.F3].includes(args.version);
   }
   function calculateInvokeTransactionHash2(args) {
     if (isV3InvokeTx(args)) {
@@ -20073,9 +20103,7 @@ var starknet = (() => {
     );
   }
   function isV3DeclareTx(args) {
-    return [ETransactionVersion4.V3, ETransactionVersion4.F3].includes(
-      args.version
-    );
+    return [ETransactionVersion4.V3, ETransactionVersion4.F3].includes(args.version);
   }
   function calculateDeclareTransactionHash3(args) {
     if (isV3DeclareTx(args)) {
@@ -20105,9 +20133,7 @@ var starknet = (() => {
     );
   }
   function isV3DeployAccountTx(args) {
-    return [ETransactionVersion4.V3, ETransactionVersion4.F3].includes(
-      args.version
-    );
+    return [ETransactionVersion4.V3, ETransactionVersion4.F3].includes(args.version);
   }
   function calculateDeployAccountTransactionHash3(args) {
     if (isV3DeployAccountTx(args)) {
@@ -20689,14 +20715,14 @@ var starknet = (() => {
   }
 
   // src/utils/json.ts
-  var parseIntAsNumberOrBigInt = (x) => {
-    if (!isInteger(x))
-      return parseFloat(x);
-    const v = parseInt(x, 10);
-    return Number.isSafeInteger(v) ? v : BigInt(x);
+  var parseIntAsNumberOrBigInt = (str) => {
+    if (!isInteger(str))
+      return parseFloat(str);
+    const num = parseInt(str, 10);
+    return Number.isSafeInteger(num) ? num : BigInt(str);
   };
-  var parse2 = (x) => parse(String(x), void 0, parseIntAsNumberOrBigInt);
-  var parseAlwaysAsBig = (x) => parse(String(x), void 0, parseNumberAndBigInt);
+  var parse2 = (str) => parse(String(str), void 0, parseIntAsNumberOrBigInt);
+  var parseAlwaysAsBig = (str) => parse(String(str), void 0, parseNumberAndBigInt);
   var stringify2 = (value, replacer, space, numberStringifiers) => stringify(value, replacer, space, numberStringifiers);
   var stringifyAlwaysAsBig = stringify2;
 
@@ -25081,10 +25107,10 @@ var starknet = (() => {
   function signatureToHexArray(sig) {
     return bigNumberishArrayToHexadecimalStringArray(formatSignature(sig));
   }
-  function estimatedFeeToMaxFee(estimatedFee, overhead = 50 /* MAX_FEE */) {
+  function estimatedFeeToMaxFee(estimatedFee, overhead = FeeMarginPercentage.MAX_FEE) {
     return addPercent(estimatedFee, overhead);
   }
-  function estimateFeeToBounds(estimate, amountOverhead = 50 /* L1_BOUND_MAX_AMOUNT */, priceOverhead = 50 /* L1_BOUND_MAX_PRICE_PER_UNIT */) {
+  function estimateFeeToBounds(estimate, amountOverhead = FeeMarginPercentage.L1_BOUND_MAX_AMOUNT, priceOverhead = FeeMarginPercentage.L1_BOUND_MAX_PRICE_PER_UNIT) {
     if (isBigInt(estimate)) {
       return {
         l2_gas: { max_amount: "0x0", max_price_per_unit: "0x0" },
@@ -25779,7 +25805,6 @@ var starknet = (() => {
   __export(provider_exports, {
     Block: () => Block,
     createSierraContractClass: () => createSierraContractClass,
-    formatHash: () => formatHash,
     getDefaultNodeUrl: () => getDefaultNodeUrl,
     isPendingBlock: () => isPendingBlock,
     isPendingStateUpdate: () => isPendingStateUpdate,
@@ -25787,7 +25812,6 @@ var starknet = (() => {
     isV3Tx: () => isV3Tx,
     isVersion: () => isVersion,
     parseContract: () => parseContract,
-    txIdentifier: () => txIdentifier,
     validBlockTags: () => validBlockTags,
     wait: () => wait
   });
@@ -25818,26 +25842,23 @@ var starknet = (() => {
     if (!mute) {
       console.warn("Using default public node url, please provide nodeUrl in provider options!");
     }
-    const nodes = RPC_NODES[networkName ?? "SN_SEPOLIA" /* SN_SEPOLIA */];
+    const nodes = RPC_NODES[networkName ?? NetworkName.SN_SEPOLIA];
     const randIdx = Math.floor(Math.random() * nodes.length);
     return nodes[randIdx];
   };
-  function formatHash(hashValue) {
-    if (isString(hashValue))
-      return hashValue;
-    return toHex(hashValue);
-  }
-  function txIdentifier(txHash, txId) {
-    if (!txHash) {
-      return `transactionId=${JSON.stringify(txId)}`;
-    }
-    const hashString = formatHash(txHash);
-    return `transactionHash=${hashString}`;
-  }
   var validBlockTags = Object.values(BlockTag);
   var Block = class {
+    /**
+     * @param {BlockIdentifier} hash if not null, contains the block hash
+     */
     hash = null;
+    /**
+     * @param {BlockIdentifier} number if not null, contains the block number
+     */
     number = null;
+    /**
+     * @param {BlockIdentifier} tag if not null, contains "pending" or "latest"
+     */
     tag = null;
     setIdentifier(__identifier) {
       if (isString(__identifier)) {
@@ -25855,16 +25876,31 @@ var starknet = (() => {
       } else if (isNumber(__identifier)) {
         this.number = __identifier;
       } else {
-        this.tag = "pending" /* pending */;
+        this.tag = BlockTag.PENDING;
       }
       if (isNumber(this.number) && this.number < 0) {
         throw TypeError(`Block number (${this.number}) can't be negative`);
       }
     }
+    /**
+     * Create a Block instance
+     * @param {BlockIdentifier} _identifier  hex string and BigInt are detected as block hashes.
+     * decimal string and number are detected as block numbers.
+     * text string are detected as block tag.
+     * null is considered as a 'pending' block tag.
+     */
     constructor(_identifier) {
       this.setIdentifier(_identifier);
     }
     // TODO: fix any
+    /**
+     * @returns {any} the identifier as a string
+     * @example
+     * ```typescript
+     * const result = new provider.Block(123456n).queryIdentifier;
+     * // result = "blockHash=0x1e240"
+     * ```
+     */
     get queryIdentifier() {
       if (this.number !== null) {
         return `blockNumber=${this.number}`;
@@ -25875,6 +25911,14 @@ var starknet = (() => {
       return `blockNumber=${this.tag}`;
     }
     // TODO: fix any
+    /**
+     * @returns {any} the identifier as an object
+     * @example
+     * ```typescript
+     * const result = new provider.Block(56789).identifier;
+     * // result = { block_number: 56789 }
+     * ```
+     */
     get identifier() {
       if (this.number !== null) {
         return { block_number: this.number };
@@ -25884,6 +25928,16 @@ var starknet = (() => {
       }
       return this.tag;
     }
+    /**
+     * change the identifier of an existing Block instance
+     * @example
+     * ```typescript
+     * const myBlock = new provider.Block("latest");
+     * myBlock.identifier ="0x3456789abc";
+     * const result = myBlock.identifier;
+     * // result = { block_hash: '0x3456789abc' }
+     * ```
+     */
     set identifier(_identifier) {
       this.setIdentifier(_identifier);
     }
@@ -26016,7 +26070,7 @@ var starknet = (() => {
   // src/channel/rpc_0_6.ts
   var defaultOptions = {
     headers: { "Content-Type": "application/json" },
-    blockIdentifier: "pending" /* pending */,
+    blockIdentifier: BlockTag.PENDING,
     retries: 200
   };
   var RpcChannel = class {
@@ -26067,7 +26121,7 @@ var starknet = (() => {
         const { code, message, data } = rpcError;
         throw new LibraryError(
           `RPC: ${method} with params ${stringify2(params, null, 2)}
- 
+
         ${code}: ${message}: ${stringify2(data)}`
         );
       }
@@ -26495,7 +26549,7 @@ var starknet = (() => {
           account_deployment_data: invocation.accountDeploymentData.map((it) => toHex(it))
         };
       }
-      if (invocation.type === "INVOKE_FUNCTION" /* INVOKE */) {
+      if (invocation.type === TransactionType.INVOKE) {
         return {
           // v0 v1 v3
           type: rpcspec_0_6_exports.ETransactionType.INVOKE,
@@ -26505,7 +26559,7 @@ var starknet = (() => {
           ...details
         };
       }
-      if (invocation.type === "DECLARE" /* DECLARE */) {
+      if (invocation.type === TransactionType.DECLARE) {
         if (!isSierra(invocation.contract)) {
           return {
             type: invocation.type,
@@ -26528,7 +26582,7 @@ var starknet = (() => {
           ...details
         };
       }
-      if (invocation.type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */) {
+      if (invocation.type === TransactionType.DEPLOY_ACCOUNT) {
         const { account_deployment_data, ...restDetails } = details;
         return {
           type: invocation.type,
@@ -26550,7 +26604,7 @@ var starknet = (() => {
   });
   var defaultOptions2 = {
     headers: { "Content-Type": "application/json" },
-    blockIdentifier: "pending" /* pending */,
+    blockIdentifier: BlockTag.PENDING,
     retries: 200
   };
   var RpcChannel2 = class {
@@ -27047,7 +27101,7 @@ var starknet = (() => {
           account_deployment_data: invocation.accountDeploymentData.map((it) => toHex(it))
         };
       }
-      if (invocation.type === "INVOKE_FUNCTION" /* INVOKE */) {
+      if (invocation.type === TransactionType.INVOKE) {
         return {
           // v0 v1 v3
           type: esm_exports.ETransactionType.INVOKE,
@@ -27057,7 +27111,7 @@ var starknet = (() => {
           ...details
         };
       }
-      if (invocation.type === "DECLARE" /* DECLARE */) {
+      if (invocation.type === TransactionType.DECLARE) {
         if (!isSierra(invocation.contract)) {
           return {
             type: invocation.type,
@@ -27080,7 +27134,7 @@ var starknet = (() => {
           ...details
         };
       }
-      if (invocation.type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */) {
+      if (invocation.type === TransactionType.DEPLOY_ACCOUNT) {
         const { account_deployment_data, ...restDetails } = details;
         return {
           type: invocation.type,
@@ -27209,13 +27263,13 @@ var starknet = (() => {
       return this.statusReceipt === "error";
     }
     static isSuccess(transactionReceipt) {
-      return transactionReceipt.execution_status === "SUCCEEDED" /* SUCCEEDED */;
+      return transactionReceipt.execution_status === TransactionExecutionStatus.SUCCEEDED;
     }
     static isReverted(transactionReceipt) {
-      return transactionReceipt.execution_status === "REVERTED" /* REVERTED */;
+      return transactionReceipt.execution_status === TransactionExecutionStatus.REVERTED;
     }
     static isRejected(transactionReceipt) {
-      return transactionReceipt.status === "REJECTED" /* REJECTED */;
+      return transactionReceipt.status === TransactionExecutionStatus.REJECTED;
     }
   };
 
@@ -27226,7 +27280,7 @@ var starknet = (() => {
     constructor(optionsOrProvider) {
       if (optionsOrProvider && "channel" in optionsOrProvider) {
         this.channel = optionsOrProvider.channel;
-        this.responseParser = optionsOrProvider.responseParser;
+        this.responseParser = "responseParser" in optionsOrProvider ? optionsOrProvider.responseParser : new RPCResponseParser();
       } else {
         this.channel = new RpcChannel2({ ...optionsOrProvider, waitMode: false });
         this.responseParser = new RPCResponseParser(optionsOrProvider?.feeMarginPercentage);
@@ -27279,10 +27333,10 @@ var starknet = (() => {
      * ```
      */
     async waitForBlock(blockIdentifier = "pending", retryInterval = 5e3) {
-      if (blockIdentifier === "latest" /* latest */)
+      if (blockIdentifier === BlockTag.LATEST)
         return;
       const currentBlock = await this.getBlockNumber();
-      const targetBlock = blockIdentifier === "pending" /* pending */ ? currentBlock + 1 : Number(toHex(blockIdentifier));
+      const targetBlock = blockIdentifier === BlockTag.PENDING ? currentBlock + 1 : Number(toHex(blockIdentifier));
       if (targetBlock <= currentBlock)
         return;
       const { retries } = this.channel;
@@ -27341,11 +27395,11 @@ var starknet = (() => {
     }
     /**
      * Return transactions from pending block
-     * @deprecated Instead use getBlock(BlockTag.pending); (will be removed in next minor version)
+     * @deprecated Instead use getBlock(BlockTag.PENDING); (will be removed in next minor version)
      * Utility method, same result can be achieved using getBlockWithTxHashes(BlockTag.pending);
      */
     async getPendingTransactions() {
-      const { transactions } = await this.getBlockWithTxHashes("pending" /* pending */).then(
+      const { transactions } = await this.getBlockWithTxHashes(BlockTag.PENDING).then(
         this.responseParser.parseGetBlockResponse
       );
       return Promise.all(transactions.map((it) => this.getTransactionByHash(it)));
@@ -27436,7 +27490,7 @@ var starknet = (() => {
       return this.channel.getEstimateFee(
         [
           {
-            type: "INVOKE_FUNCTION" /* INVOKE */,
+            type: TransactionType.INVOKE,
             ...invocation,
             ...invocationDetails
           }
@@ -27448,7 +27502,7 @@ var starknet = (() => {
       return this.channel.getEstimateFee(
         [
           {
-            type: "DECLARE" /* DECLARE */,
+            type: TransactionType.DECLARE,
             ...invocation,
             ...details
           }
@@ -27460,7 +27514,7 @@ var starknet = (() => {
       return this.channel.getEstimateFee(
         [
           {
-            type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
+            type: TransactionType.DEPLOY_ACCOUNT,
             ...invocation,
             ...details
           }
@@ -27835,32 +27889,30 @@ var starknet = (() => {
     }
     return encoded;
   }
-  var StarknetIdContract = /* @__PURE__ */ ((StarknetIdContract2) => {
-    StarknetIdContract2["MAINNET"] = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678";
-    StarknetIdContract2["TESTNET_SEPOLIA"] = "0x0707f09bc576bd7cfee59694846291047e965f4184fe13dac62c56759b3b6fa7";
-    return StarknetIdContract2;
-  })(StarknetIdContract || {});
+  var StarknetIdContract = {
+    MAINNET: "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678",
+    TESTNET_SEPOLIA: "0x154bc2e1af9260b9e66af0e9c46fc757ff893b3ff6a85718a810baf1474"
+  };
   function getStarknetIdContract(chainId) {
     switch (chainId) {
-      case "0x534e5f4d41494e" /* SN_MAIN */:
-        return "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678" /* MAINNET */;
-      case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
-        return "0x0707f09bc576bd7cfee59694846291047e965f4184fe13dac62c56759b3b6fa7" /* TESTNET_SEPOLIA */;
+      case StarknetChainId.SN_MAIN:
+        return StarknetIdContract.MAINNET;
+      case StarknetChainId.SN_SEPOLIA:
+        return StarknetIdContract.TESTNET_SEPOLIA;
       default:
         throw new Error("Starknet.id is not yet deployed on this network");
     }
   }
-  var StarknetIdIdentityContract = /* @__PURE__ */ ((StarknetIdIdentityContract2) => {
-    StarknetIdIdentityContract2["MAINNET"] = "0x05dbdedc203e92749e2e746e2d40a768d966bd243df04a6b712e222bc040a9af";
-    StarknetIdIdentityContract2["TESTNET_SEPOLIA"] = "0x070DF8B4F5cb2879f8592849fA8f3134da39d25326B8558cc9C8FE8D47EA3A90";
-    return StarknetIdIdentityContract2;
-  })(StarknetIdIdentityContract || {});
+  var StarknetIdIdentityContract = {
+    MAINNET: "0x05dbdedc203e92749e2e746e2d40a768d966bd243df04a6b712e222bc040a9af",
+    TESTNET_SEPOLIA: "0x3697660a0981d734780731949ecb2b4a38d6a58fc41629ed611e8defda"
+  };
   function getStarknetIdIdentityContract(chainId) {
     switch (chainId) {
-      case "0x534e5f4d41494e" /* SN_MAIN */:
-        return "0x05dbdedc203e92749e2e746e2d40a768d966bd243df04a6b712e222bc040a9af" /* MAINNET */;
-      case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
-        return "0x070DF8B4F5cb2879f8592849fA8f3134da39d25326B8558cc9C8FE8D47EA3A90" /* TESTNET_SEPOLIA */;
+      case StarknetChainId.SN_MAIN:
+        return StarknetIdIdentityContract.MAINNET;
+      case StarknetChainId.SN_SEPOLIA:
+        return StarknetIdIdentityContract.TESTNET_SEPOLIA;
       default:
         throw new Error("Starknet.id verifier contract is not yet deployed on this network");
     }
@@ -27868,57 +27920,54 @@ var starknet = (() => {
   var StarknetIdMulticallContract = "0x034ffb8f4452df7a613a0210824d6414dbadcddce6c6e19bf4ddc9e22ce5f970";
   function getStarknetIdMulticallContract(chainId) {
     switch (chainId) {
-      case "0x534e5f4d41494e" /* SN_MAIN */:
+      case StarknetChainId.SN_MAIN:
         return StarknetIdMulticallContract;
-      case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
+      case StarknetChainId.SN_SEPOLIA:
         return StarknetIdMulticallContract;
       default:
         throw new Error("Starknet.id multicall contract is not yet deployed on this network");
     }
   }
-  var StarknetIdVerifierContract = /* @__PURE__ */ ((StarknetIdVerifierContract2) => {
-    StarknetIdVerifierContract2["MAINNET"] = "0x07d14dfd8ee95b41fce179170d88ba1f0d5a512e13aeb232f19cfeec0a88f8bf";
-    StarknetIdVerifierContract2["TESTNET_SEPOLIA"] = "0x0182EcE8173C216A395f4828e1523541b7e3600bf190CB252E1a1A0cE219d184";
-    return StarknetIdVerifierContract2;
-  })(StarknetIdVerifierContract || {});
+  var StarknetIdVerifierContract = {
+    MAINNET: "0x07d14dfd8ee95b41fce179170d88ba1f0d5a512e13aeb232f19cfeec0a88f8bf",
+    TESTNET_SEPOLIA: "0x60B94fEDe525f815AE5E8377A463e121C787cCCf3a36358Aa9B18c12c4D566"
+  };
   function getStarknetIdVerifierContract(chainId) {
     switch (chainId) {
-      case "0x534e5f4d41494e" /* SN_MAIN */:
-        return "0x07d14dfd8ee95b41fce179170d88ba1f0d5a512e13aeb232f19cfeec0a88f8bf" /* MAINNET */;
-      case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
-        return "0x0182EcE8173C216A395f4828e1523541b7e3600bf190CB252E1a1A0cE219d184" /* TESTNET_SEPOLIA */;
+      case StarknetChainId.SN_MAIN:
+        return StarknetIdVerifierContract.MAINNET;
+      case StarknetChainId.SN_SEPOLIA:
+        return StarknetIdVerifierContract.TESTNET_SEPOLIA;
       default:
         throw new Error("Starknet.id verifier contract is not yet deployed on this network");
     }
   }
-  var StarknetIdPfpContract = /* @__PURE__ */ ((StarknetIdPfpContract2) => {
-    StarknetIdPfpContract2["MAINNET"] = "0x070aaa20ec4a46da57c932d9fd89ca5e6bb9ca3188d3df361a32306aff7d59c7";
-    StarknetIdPfpContract2["TESTNET_SEPOLIA"] = "0x058061bb6bdc501eE215172c9f87d557C1E0f466dC498cA81b18f998Bf1362b2";
-    return StarknetIdPfpContract2;
-  })(StarknetIdPfpContract || {});
+  var StarknetIdPfpContract = {
+    MAINNET: "0x070aaa20ec4a46da57c932d9fd89ca5e6bb9ca3188d3df361a32306aff7d59c7",
+    TESTNET_SEPOLIA: "0x9e7bdb8dabd02ea8cfc23b1d1c5278e46490f193f87516ed5ff2dfec02"
+  };
   function getStarknetIdPfpContract(chainId) {
     switch (chainId) {
-      case "0x534e5f4d41494e" /* SN_MAIN */:
-        return "0x070aaa20ec4a46da57c932d9fd89ca5e6bb9ca3188d3df361a32306aff7d59c7" /* MAINNET */;
-      case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
-        return "0x058061bb6bdc501eE215172c9f87d557C1E0f466dC498cA81b18f998Bf1362b2" /* TESTNET_SEPOLIA */;
+      case StarknetChainId.SN_MAIN:
+        return StarknetIdPfpContract.MAINNET;
+      case StarknetChainId.SN_SEPOLIA:
+        return StarknetIdPfpContract.TESTNET_SEPOLIA;
       default:
         throw new Error(
           "Starknet.id profile picture verifier contract is not yet deployed on this network"
         );
     }
   }
-  var StarknetIdPopContract = /* @__PURE__ */ ((StarknetIdPopContract2) => {
-    StarknetIdPopContract2["MAINNET"] = "0x0293eb2ba9862f762bd3036586d5755a782bd22e6f5028320f1d0405fd47bff4";
-    StarknetIdPopContract2["TESTNET_SEPOLIA"] = "0x0023FE3b845ed5665a9eb3792bbB17347B490EE4090f855C1298d03BB5F49B49";
-    return StarknetIdPopContract2;
-  })(StarknetIdPopContract || {});
+  var StarknetIdPopContract = {
+    MAINNET: "0x0293eb2ba9862f762bd3036586d5755a782bd22e6f5028320f1d0405fd47bff4",
+    TESTNET_SEPOLIA: "0x15ae88ae054caa74090b89025c1595683f12edf7a4ed2ad0274de3e1d4a"
+  };
   function getStarknetIdPopContract(chainId) {
     switch (chainId) {
-      case "0x534e5f4d41494e" /* SN_MAIN */:
-        return "0x0293eb2ba9862f762bd3036586d5755a782bd22e6f5028320f1d0405fd47bff4" /* MAINNET */;
-      case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
-        return "0x0023FE3b845ed5665a9eb3792bbB17347B490EE4090f855C1298d03BB5F49B49" /* TESTNET_SEPOLIA */;
+      case StarknetChainId.SN_MAIN:
+        return StarknetIdPopContract.MAINNET;
+      case StarknetChainId.SN_SEPOLIA:
+        return StarknetIdPopContract.TESTNET_SEPOLIA;
       default:
         throw new Error(
           "Starknet.id proof of personhood verifier contract is not yet deployed on this network"
@@ -27981,7 +28030,14 @@ var starknet = (() => {
       const chainId = await provider.getChainId();
       const contract = StarknetIdContract2 ?? getStarknetIdContract(chainId);
       try {
-        const hexDomain = await this.executeStarkName(provider, address, contract);
+        const hexDomain = await provider.callContract({
+          contractAddress: contract,
+          entrypoint: "address_to_domain",
+          calldata: CallData.compile({
+            address,
+            hint: []
+          })
+        });
         const decimalDomain = hexDomain.map((element) => BigInt(element)).slice(1);
         const stringDomain = useDecoded(decimalDomain);
         if (!stringDomain) {
@@ -27995,26 +28051,6 @@ var starknet = (() => {
         throw Error("Could not get stark name");
       }
     }
-    static async executeStarkName(provider, address, contract) {
-      try {
-        return await provider.callContract({
-          contractAddress: contract,
-          entrypoint: "address_to_domain",
-          calldata: CallData.compile({
-            address,
-            hint: []
-          })
-        });
-      } catch (initialError) {
-        return await provider.callContract({
-          contractAddress: contract,
-          entrypoint: "address_to_domain",
-          calldata: CallData.compile({
-            address
-          })
-        });
-      }
-    }
     static async getAddressFromStarkName(provider, name, StarknetIdContract2) {
       const chainId = await provider.getChainId();
       const contract = StarknetIdContract2 ?? getStarknetIdContract(chainId);
@@ -28039,21 +28075,13 @@ var starknet = (() => {
       const popContract = StarknetIdPopContract2 ?? getStarknetIdPopContract(chainId);
       const multicallAddress = StarknetIdMulticallContract2 ?? getStarknetIdMulticallContract(chainId);
       try {
-        const initialCalldata = [];
-        const fallbackCalldata = [];
-        initialCalldata.push({
-          execution: execution({}),
-          to: dynamicCallData(contract),
-          selector: dynamicCallData(getSelectorFromName("address_to_domain")),
-          calldata: [dynamicCallData(address), dynamicCallData("0")]
-        });
-        fallbackCalldata.push({
-          execution: execution({}),
-          to: dynamicCallData(contract),
-          selector: dynamicFelt(getSelectorFromName("address_to_domain")),
-          calldata: [dynamicCallData(address)]
-        });
         const calls = [
+          {
+            execution: execution({}),
+            to: dynamicCallData(contract),
+            selector: dynamicCallData(getSelectorFromName("address_to_domain")),
+            calldata: [dynamicCallData(address), dynamicCallData("0")]
+          },
           {
             execution: execution({}),
             to: dynamicFelt(contract),
@@ -28135,15 +28163,13 @@ var starknet = (() => {
             calldata: [dynamicCallData(void 0, [7, 1]), dynamicCallData(void 0, [7, 2])]
           }
         ];
-        initialCalldata.push(...calls);
-        fallbackCalldata.push(...calls);
-        const data = await this.executeStarkProfile(
-          provider,
-          multicallAddress,
-          "aggregate",
-          initialCalldata,
-          fallbackCalldata
-        );
+        const data = await provider.callContract({
+          contractAddress: multicallAddress,
+          entrypoint: "aggregate",
+          calldata: CallData.compile({
+            calls
+          })
+        });
         if (Array.isArray(data)) {
           const size = parseInt(data[0], 16);
           const finalArray = [];
@@ -28183,25 +28209,6 @@ var starknet = (() => {
         throw Error("Could not get user stark profile data from address");
       }
     }
-    static async executeStarkProfile(provider, contract, functionName, initialCalldata, fallbackCalldata) {
-      try {
-        return await provider.callContract({
-          contractAddress: contract,
-          entrypoint: functionName,
-          calldata: CallData.compile({
-            calls: initialCalldata
-          })
-        });
-      } catch (initialError) {
-        return await provider.callContract({
-          contractAddress: contract,
-          entrypoint: functionName,
-          calldata: CallData.compile({
-            calls: fallbackCalldata
-          })
-        });
-      }
-    }
   };
 
   // src/provider/extensions/default.ts
@@ -28245,16 +28252,30 @@ var starknet = (() => {
     branches = [];
     root;
     hashMethod;
+    /**
+     * Create a Merkle tree
+     *
+     * @param leafHashes hex-string array
+     * @param hashMethod hash method to use, default: Pedersen
+     * @returns created Merkle tree
+     * @example
+     * ```typescript
+     * const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'];
+     * const tree = new MerkleTree(leaves);
+     * // tree = {
+     * //   branches: [['0x5bb9440e2...', '0x262697b88...', ...], ['0x38118a340...', ...], ...],
+     * //   leaves: ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'],
+     * //   root: '0x7f748c75e5bdb7ae28013f076b8ab650c4e01d3530c6e5ab665f9f1accbe7d4',
+     * //   hashMethod: [Function computePedersenHash],
+     * // }
+     * ```
+     */
     constructor(leafHashes, hashMethod = computePedersenHash) {
       this.hashMethod = hashMethod;
       this.leaves = leafHashes;
       this.root = this.build(leafHashes);
     }
-    /**
-     * Create Merkle tree
-     * @param leaves hex-string array
-     * @returns format: hex-string; Merkle tree root
-     */
+    /** @ignore */
     build(leaves) {
       if (leaves.length === 1) {
         return leaves[0];
@@ -28273,19 +28294,44 @@ var starknet = (() => {
       return this.build(newLeaves);
     }
     /**
-     * Create hash from ordered a and b, Pedersen hash default
-     * @returns format: hex-string
+     * Calculate hash from ordered a and b, Pedersen hash default
+     *
+     * @param a first value
+     * @param b second value
+     * @param hashMethod hash method to use, default: Pedersen
+     * @returns result of the hash function
+     * @example
+     * ```typescript
+     * const result1 = MerkleTree.hash('0xabc', '0xdef');
+     * // result1 = '0x484f029da7914ada038b1adf67fc83632364a3ebc2cd9349b41ab61626d9e82'
+     *
+     * const customHashMethod = (a, b) => `custom_${a}_${b}`;
+     * const result2 = MerkleTree.hash('0xabc', '0xdef', customHashMethod);
+     * // result2 = 'custom_2748_3567'
+     * ```
      */
     static hash(a, b, hashMethod = computePedersenHash) {
       const [aSorted, bSorted] = [BigInt(a), BigInt(b)].sort((x, y) => x >= y ? 1 : -1);
       return hashMethod(aSorted, bSorted);
     }
     /**
-     * Return path to leaf
+     * Calculates the merkle membership proof path
+     *
      * @param leaf hex-string
      * @param branch hex-string array
      * @param hashPath hex-string array
-     * @returns format: hex-string array
+     * @returns collection of merkle proof hex-string hashes
+     * @example
+     * ```typescript
+     * const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'];
+     * const tree = new MerkleTree(leaves);
+     * const result = tree.getProof('0x3');
+     * // result = [
+     * //   '0x4',
+     * //   '0x5bb9440e27889a364bcb678b1f679ecd1347acdedcbf36e83494f857cc58026',
+     * //   '0x8c0e46dd2df9aaf3a8ebfbc25408a582ad7fa7171f0698ddbbc5130b4b4e60',
+     * // ]
+     * ```
      */
     getProof(leaf, branch = this.leaves, hashPath = []) {
       const index = branch.indexOf(leaf);
@@ -28326,14 +28372,14 @@ var starknet = (() => {
     )
   };
   var revisionConfiguration = {
-    [TypedDataRevision.Active]: {
+    [TypedDataRevision.ACTIVE]: {
       domain: "StarknetDomain",
       hashMethod: computePoseidonHashOnElements,
       hashMerkleMethod: computePoseidonHash,
       escapeTypeString: (s) => `"${s}"`,
       presetTypes
     },
-    [TypedDataRevision.Legacy]: {
+    [TypedDataRevision.LEGACY]: {
       domain: "StarkNetDomain",
       hashMethod: computePedersenHashOnElements,
       hashMerkleMethod: computePedersenHash,
@@ -28346,10 +28392,10 @@ var starknet = (() => {
     assert(value >= min && value <= max, `${value} (${type}) is out of bounds [${min}, ${max}]`);
   }
   function identifyRevision({ types, domain }) {
-    if (revisionConfiguration[TypedDataRevision.Active].domain in types && domain.revision === TypedDataRevision.Active)
-      return TypedDataRevision.Active;
-    if (revisionConfiguration[TypedDataRevision.Legacy].domain in types && (domain.revision ?? TypedDataRevision.Legacy) === TypedDataRevision.Legacy)
-      return TypedDataRevision.Legacy;
+    if (revisionConfiguration[TypedDataRevision.ACTIVE].domain in types && domain.revision === TypedDataRevision.ACTIVE)
+      return TypedDataRevision.ACTIVE;
+    if (revisionConfiguration[TypedDataRevision.LEGACY].domain in types && (domain.revision ?? TypedDataRevision.LEGACY) === TypedDataRevision.LEGACY)
+      return TypedDataRevision.LEGACY;
     return void 0;
   }
   function getHex(value) {
@@ -28374,10 +28420,10 @@ var starknet = (() => {
   function isMerkleTreeType(type) {
     return type.type === "merkletree";
   }
-  function getDependencies(types, type, dependencies = [], contains = "", revision = TypedDataRevision.Legacy) {
+  function getDependencies(types, type, dependencies = [], contains = "", revision = TypedDataRevision.LEGACY) {
     if (type[type.length - 1] === "*") {
       type = type.slice(0, -1);
-    } else if (revision === TypedDataRevision.Active) {
+    } else if (revision === TypedDataRevision.ACTIVE) {
       if (type === "enum") {
         type = contains;
       } else if (type.match(/^\(.*\)$/)) {
@@ -28415,8 +28461,8 @@ var starknet = (() => {
     }
     return "raw";
   }
-  function encodeType(types, type, revision = TypedDataRevision.Legacy) {
-    const allTypes = revision === TypedDataRevision.Active ? { ...types, ...revisionConfiguration[revision].presetTypes } : types;
+  function encodeType(types, type, revision = TypedDataRevision.LEGACY) {
+    const allTypes = revision === TypedDataRevision.ACTIVE ? { ...types, ...revisionConfiguration[revision].presetTypes } : types;
     const [primary, ...dependencies] = getDependencies(
       allTypes,
       type,
@@ -28428,17 +28474,17 @@ var starknet = (() => {
     const esc = revisionConfiguration[revision].escapeTypeString;
     return newTypes.map((dependency) => {
       const dependencyElements = allTypes[dependency].map((t) => {
-        const targetType = t.type === "enum" && revision === TypedDataRevision.Active ? t.contains : t.type;
+        const targetType = t.type === "enum" && revision === TypedDataRevision.ACTIVE ? t.contains : t.type;
         const typeString = targetType.match(/^\(.*\)$/) ? `(${targetType.slice(1, -1).split(",").map((e) => e ? esc(e) : e).join(",")})` : esc(targetType);
         return `${esc(t.name)}:${typeString}`;
       });
       return `${esc(dependency)}(${dependencyElements})`;
     }).join("");
   }
-  function getTypeHash(types, type, revision = TypedDataRevision.Legacy) {
+  function getTypeHash(types, type, revision = TypedDataRevision.LEGACY) {
     return getSelectorFromName(encodeType(types, type, revision));
   }
-  function encodeValue(types, type, data, ctx = {}, revision = TypedDataRevision.Legacy) {
+  function encodeValue(types, type, data, ctx = {}, revision = TypedDataRevision.LEGACY) {
     if (types[type]) {
       return [type, getStructHash(types, type, data, revision)];
     }
@@ -28461,7 +28507,7 @@ var starknet = (() => {
     }
     switch (type) {
       case "enum": {
-        if (revision === TypedDataRevision.Active) {
+        if (revision === TypedDataRevision.ACTIVE) {
           const [variantKey, variantData] = Object.entries(data)[0];
           const parentType = types[ctx.parent][0];
           const enumType = types[parentType.contains];
@@ -28495,7 +28541,7 @@ var starknet = (() => {
         return ["felt", prepareSelector(data)];
       }
       case "string": {
-        if (revision === TypedDataRevision.Active) {
+        if (revision === TypedDataRevision.ACTIVE) {
           const byteArray = byteArrayFromString(data);
           const elements = [
             byteArray.data.length,
@@ -28508,7 +28554,7 @@ var starknet = (() => {
         return [type, getHex(data)];
       }
       case "i128": {
-        if (revision === TypedDataRevision.Active) {
+        if (revision === TypedDataRevision.ACTIVE) {
           const value = BigInt(data);
           assertRange(value, type, RANGE_I128);
           return [type, getHex(value < 0n ? PRIME + value : value)];
@@ -28517,40 +28563,40 @@ var starknet = (() => {
       }
       case "timestamp":
       case "u128": {
-        if (revision === TypedDataRevision.Active) {
+        if (revision === TypedDataRevision.ACTIVE) {
           assertRange(data, type, RANGE_U128);
         }
         return [type, getHex(data)];
       }
       case "felt":
       case "shortstring": {
-        if (revision === TypedDataRevision.Active) {
+        if (revision === TypedDataRevision.ACTIVE) {
           assertRange(getHex(data), type, RANGE_FELT);
         }
         return [type, getHex(data)];
       }
       case "ClassHash":
       case "ContractAddress": {
-        if (revision === TypedDataRevision.Active) {
+        if (revision === TypedDataRevision.ACTIVE) {
           assertRange(data, type, RANGE_FELT);
         }
         return [type, getHex(data)];
       }
       case "bool": {
-        if (revision === TypedDataRevision.Active) {
+        if (revision === TypedDataRevision.ACTIVE) {
           assert(typeof data === "boolean", `Type mismatch for ${type} ${data}`);
         }
         return [type, getHex(data)];
       }
       default: {
-        if (revision === TypedDataRevision.Active) {
+        if (revision === TypedDataRevision.ACTIVE) {
           throw new Error(`Unsupported type: ${type}`);
         }
         return [type, getHex(data)];
       }
     }
   }
-  function encodeData(types, type, data, revision = TypedDataRevision.Legacy) {
+  function encodeData(types, type, data, revision = TypedDataRevision.LEGACY) {
     const targetType = types[type] ?? revisionConfiguration[revision].presetTypes[type];
     const [returnTypes, values] = targetType.reduce(
       ([ts, vs], field) => {
@@ -28569,7 +28615,7 @@ var starknet = (() => {
     );
     return [returnTypes, values];
   }
-  function getStructHash(types, type, data, revision = TypedDataRevision.Legacy) {
+  function getStructHash(types, type, data, revision = TypedDataRevision.LEGACY) {
     return revisionConfiguration[revision].hashMethod(encodeData(types, type, data, revision)[1]);
   }
   function getMessageHash(typedData, account) {
@@ -28824,7 +28870,128 @@ var starknet = (() => {
     }
   };
 
-  // src/utils/events.ts
+  // src/utils/events/index.ts
+  var events_exports = {};
+  __export(events_exports, {
+    getAbiEvents: () => getAbiEvents,
+    isAbiEvent: () => isAbiEvent,
+    isObject: () => isObject2,
+    parseEvents: () => parseEvents,
+    parseUDCEvent: () => parseUDCEvent
+  });
+  function isAbiEvent(object) {
+    return object.type === "event";
+  }
+  function getCairo0AbiEvents(abi) {
+    return abi.filter((abiEntry) => abiEntry.type === "event").reduce((acc, abiEntry) => {
+      const entryName = abiEntry.name;
+      const abiEntryMod = { ...abiEntry };
+      abiEntryMod.name = entryName;
+      return {
+        ...acc,
+        [addHexPrefix(esm_exports2.keccak(utf8ToArray(entryName)).toString(16))]: abiEntryMod
+      };
+    }, {});
+  }
+  function getCairo1AbiEvents(abi) {
+    const abiEventsStructs = abi.filter((obj) => isAbiEvent(obj) && obj.kind === "struct");
+    const abiEventsEnums = abi.filter((obj) => isAbiEvent(obj) && obj.kind === "enum");
+    const abiEventsData = abiEventsStructs.reduce((acc, event) => {
+      let nameList = [];
+      let { name } = event;
+      let flat = false;
+      const findName = (variant) => variant.type === name;
+      while (true) {
+        const eventEnum = abiEventsEnums.find((eventE) => eventE.variants.some(findName));
+        if (typeof eventEnum === "undefined")
+          break;
+        const variant = eventEnum.variants.find(findName);
+        nameList.unshift(variant.name);
+        if (variant.kind === "flat")
+          flat = true;
+        name = eventEnum.name;
+      }
+      if (nameList.length === 0) {
+        throw new Error("inconsistency in ABI events definition.");
+      }
+      if (flat)
+        nameList = [nameList[nameList.length - 1]];
+      const final = nameList.pop();
+      let result = {
+        [addHexPrefix(esm_exports2.keccak(utf8ToArray(final)).toString(16))]: event
+      };
+      while (nameList.length > 0) {
+        result = {
+          [addHexPrefix(esm_exports2.keccak(utf8ToArray(nameList.pop())).toString(16))]: result
+        };
+      }
+      result = { ...result };
+      return mergeAbiEvents(acc, result);
+    }, {});
+    return abiEventsData;
+  }
+  function getAbiEvents(abi) {
+    return isCairo1Abi(abi) ? getCairo1AbiEvents(abi) : getCairo0AbiEvents(abi);
+  }
+  function isObject2(item) {
+    return item && typeof item === "object" && !Array.isArray(item);
+  }
+  function mergeAbiEvents(target, source) {
+    const output3 = { ...target };
+    if (isObject2(target) && isObject2(source)) {
+      Object.keys(source).forEach((key) => {
+        if (isObject2(source[key])) {
+          if (!(key in target))
+            Object.assign(output3, { [key]: source[key] });
+          else
+            output3[key] = mergeAbiEvents(target[key], source[key]);
+        } else {
+          Object.assign(output3, { [key]: source[key] });
+        }
+      });
+    }
+    return output3;
+  }
+  function parseEvents(providerReceivedEvents, abiEvents, abiStructs, abiEnums) {
+    const ret = providerReceivedEvents.flat().reduce((acc, recEvent) => {
+      let abiEvent = abiEvents[recEvent.keys.shift() ?? 0];
+      if (!abiEvent) {
+        return acc;
+      }
+      while (!abiEvent.name) {
+        const hashName = recEvent.keys.shift();
+        assert(!!hashName, 'Not enough data in "key" property of this event.');
+        abiEvent = abiEvent[hashName];
+      }
+      const parsedEvent = {};
+      parsedEvent[abiEvent.name] = {};
+      const keysIter = recEvent.keys[Symbol.iterator]();
+      const dataIter = recEvent.data[Symbol.iterator]();
+      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]
+        );
+      });
+      abiEventData.forEach((data) => {
+        parsedEvent[abiEvent.name][data.name] = responseParser(
+          dataIter,
+          data,
+          abiStructs,
+          abiEnums,
+          parsedEvent[abiEvent.name]
+        );
+      });
+      acc.push(parsedEvent);
+      return acc;
+    }, []);
+    return ret;
+  }
   function parseUDCEvent(txReceipt) {
     if (!txReceipt.events) {
       throw new Error("UDC emitted event is empty");
@@ -29051,7 +29218,7 @@ var starknet = (() => {
       );
       const estimate = await this.getUniversalSuggestedFee(
         version,
-        { type: "INVOKE_FUNCTION" /* INVOKE */, payload: transactions },
+        { type: TransactionType.INVOKE, payload: transactions },
         {
           ...details,
           version
@@ -29109,7 +29276,7 @@ var starknet = (() => {
       const estimate = await this.getUniversalSuggestedFee(
         version,
         {
-          type: "DECLARE" /* DECLARE */,
+          type: TransactionType.DECLARE,
           payload: declareContractPayload
         },
         {
@@ -29177,7 +29344,7 @@ var starknet = (() => {
       const estimate = await this.getUniversalSuggestedFee(
         version,
         {
-          type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
+          type: TransactionType.DEPLOY_ACCOUNT,
           payload: {
             classHash,
             constructorCalldata: compiledCalldata,
@@ -29294,16 +29461,16 @@ var starknet = (() => {
     async getSuggestedFee({ type, payload }, details) {
       let feeEstimate;
       switch (type) {
-        case "INVOKE_FUNCTION" /* INVOKE */:
+        case TransactionType.INVOKE:
           feeEstimate = await this.estimateInvokeFee(payload, details);
           break;
-        case "DECLARE" /* DECLARE */:
+        case TransactionType.DECLARE:
           feeEstimate = await this.estimateDeclareFee(payload, details);
           break;
-        case "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */:
+        case TransactionType.DEPLOY_ACCOUNT:
           feeEstimate = await this.estimateAccountDeployFee(payload, details);
           break;
-        case "DEPLOY" /* DEPLOY */:
+        case TransactionType.DEPLOY:
           feeEstimate = await this.estimateDeployFee(payload, details);
           break;
         default:
@@ -29405,7 +29572,7 @@ var starknet = (() => {
       const chainId = await this.getChainId();
       const versions = details.versions.map((it) => toTransactionVersion(it));
       const tx0Payload = "payload" in invocations[0] ? invocations[0].payload : invocations[0];
-      const cairoVersion = invocations[0].type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */ ? await this.getCairoVersion(tx0Payload.classHash) : await this.getCairoVersion();
+      const cairoVersion = invocations[0].type === TransactionType.DEPLOY_ACCOUNT ? await this.getCairoVersion(tx0Payload.classHash) : await this.getCairoVersion();
       return Promise.all(
         [].concat(invocations).map(async (transaction, index) => {
           const txPayload = "payload" in transaction ? transaction.payload : transaction;
@@ -29425,7 +29592,7 @@ var starknet = (() => {
             blockIdentifier,
             version: ""
           };
-          if (transaction.type === "INVOKE_FUNCTION" /* INVOKE */) {
+          if (transaction.type === TransactionType.INVOKE) {
             const versionX = reduceV2(versions[1]);
             signerDetails.version = versionX;
             common2.version = versionX;
@@ -29438,7 +29605,7 @@ var starknet = (() => {
               ...payload
             };
           }
-          if (transaction.type === "DEPLOY" /* DEPLOY */) {
+          if (transaction.type === TransactionType.DEPLOY) {
             const versionX = reduceV2(versions[1]);
             signerDetails.version = versionX;
             common2.version = versionX;
@@ -29447,10 +29614,10 @@ var starknet = (() => {
             return {
               ...common2,
               ...payload,
-              type: "INVOKE_FUNCTION" /* INVOKE */
+              type: TransactionType.INVOKE
             };
           }
-          if (transaction.type === "DECLARE" /* DECLARE */) {
+          if (transaction.type === TransactionType.DECLARE) {
             const versionX = !isSierra(txPayload.contract) ? versions[0] : versions[1];
             signerDetails.version = versionX;
             common2.version = versionX;
@@ -29460,7 +29627,7 @@ var starknet = (() => {
               ...payload
             };
           }
-          if (transaction.type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */) {
+          if (transaction.type === TransactionType.DEPLOY_ACCOUNT) {
             const versionX = reduceV2(versions[1]);
             signerDetails.version = versionX;
             common2.version = versionX;
@@ -29665,60 +29832,6 @@ var starknet = (() => {
     // TODO: MISSING ESTIMATES
   };
 
-  // src/utils/events/index.ts
-  var events_exports = {};
-  __export(events_exports, {
-    getAbiEvents: () => getAbiEvents,
-    parseEvents: () => parseEvents
-  });
-  function getAbiEvents(abi) {
-    return abi.filter((abiEntry) => abiEntry.type === "event" && (abiEntry.size || abiEntry.kind !== "enum")).reduce((acc, abiEntry) => {
-      const entryName = abiEntry.name.slice(abiEntry.name.lastIndexOf(":") + 1);
-      const abiEntryMod = { ...abiEntry };
-      abiEntryMod.name = entryName;
-      return {
-        ...acc,
-        [addHexPrefix(esm_exports2.keccak(utf8ToArray(entryName)).toString(16))]: abiEntryMod
-      };
-    }, {});
-  }
-  function parseEvents(providerReceivedEvents, abiEvents, abiStructs, abiEnums) {
-    const ret = providerReceivedEvents.flat().reduce((acc, recEvent) => {
-      const abiEvent = abiEvents[recEvent.keys[0]];
-      if (!abiEvent) {
-        return acc;
-      }
-      const parsedEvent = {};
-      parsedEvent[abiEvent.name] = {};
-      recEvent.keys.shift();
-      const keysIter = recEvent.keys[Symbol.iterator]();
-      const dataIter = recEvent.data[Symbol.iterator]();
-      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]
-        );
-      });
-      abiEventData.forEach((data) => {
-        parsedEvent[abiEvent.name][data.name] = responseParser(
-          dataIter,
-          data,
-          abiStructs,
-          abiEnums,
-          parsedEvent[abiEvent.name]
-        );
-      });
-      acc.push(parsedEvent);
-      return acc;
-    }, []);
-    return ret;
-  }
-
   // src/contract/default.ts
   var splitArgsAndOptions = (args) => {
     const options = [
@@ -29871,7 +29984,7 @@ var starknet = (() => {
       assert(this.address !== null, "contract is not connected to an address");
       const calldata = getCalldata(args, () => {
         if (parseRequest) {
-          this.callData.validate("CALL" /* CALL */, method, args);
+          this.callData.validate(ValidateType.CALL, method, args);
           return this.callData.compile(method, args);
         }
         console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
@@ -29898,7 +30011,7 @@ var starknet = (() => {
       assert(this.address !== null, "contract is not connected to an address");
       const calldata = getCalldata(args, () => {
         if (parseRequest) {
-          this.callData.validate("INVOKE" /* INVOKE */, method, args);
+          this.callData.validate(ValidateType.INVOKE, method, args);
           return this.callData.compile(method, args);
         }
         console.warn("Invoke skipped parsing but provided rawArgs, possible malfunction request");
@@ -29931,7 +30044,7 @@ var starknet = (() => {
     async estimate(method, args = []) {
       assert(this.address !== null, "contract is not connected to an address");
       if (!getCalldata(args, () => false)) {
-        this.callData.validate("INVOKE" /* INVOKE */, method, args);
+        this.callData.validate(ValidateType.INVOKE, method, args);
       }
       const invocation = this.populate(method, args);
       if ("estimateInvokeFee" in this.providerOrAccount) {
@@ -30013,7 +30126,7 @@ var starknet = (() => {
       const { args: param, options = { parseRequest: true } } = splitArgsAndOptions(args);
       const constructorCalldata = getCalldata(param, () => {
         if (options.parseRequest) {
-          this.CallData.validate("DEPLOY" /* DEPLOY */, "constructor", param);
+          this.CallData.validate(ValidateType.DEPLOY, "constructor", param);
           return this.CallData.compile("constructor", param);
         }
         console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
@@ -30056,16 +30169,22 @@ var starknet = (() => {
     // ethers.js' getDeployTransaction can't be supported as it requires the account or signer to return a signed transaction which is not possible with the current implementation
   };
 
+  // src/utils/responseParser/interface.ts
+  var ResponseParser = class {
+  };
+
   // src/utils/address.ts
   function addAddressPadding(address) {
-    return addHexPrefix(removeHexPrefix(toHex(address)).padStart(64, "0"));
+    const hex = toHex(addHexPrefix(address.toString()));
+    const padded = removeHexPrefix(hex).padStart(64, "0");
+    return addHexPrefix(padded);
   }
   function validateAndParseAddress(address) {
-    assertInRange(address, ZERO, ADDR_BOUND - 1n, "Starknet Address");
     const result = addAddressPadding(address);
     if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
       throw new Error("Invalid Address Format");
     }
+    assertInRange(result, ZERO, ADDR_BOUND - 1n, "Starknet Address");
     return result;
   }
   function getChecksumAddress(address) {