starknet 6.7.0 → 6.9.0

package/dist/index.js

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -60,14 +61,13 @@ __export(src_exports, {
   ReceiptTx: () => ReceiptTx,
   RpcChannel: () => RpcChannel2,
   RpcProvider: () => RpcProvider2,
-  SIMULATION_FLAG: () => SIMULATION_FLAG,
   Signer: () => Signer,
   SignerInterface: () => SignerInterface,
   TransactionExecutionStatus: () => TransactionExecutionStatus,
   TransactionFinalityStatus: () => TransactionFinalityStatus,
   TransactionStatus: () => TransactionStatus,
   TransactionType: () => TransactionType,
-  TypedDataRevision: () => import_starknet_types.TypedDataRevision,
+  TypedDataRevision: () => import_starknet_types_07.TypedDataRevision,
   UINT_128_MAX: () => UINT_128_MAX,
   UINT_128_MIN: () => UINT_128_MIN,
   UINT_256_HIGH_MAX: () => UINT_256_HIGH_MAX,
@@ -104,6 +104,7 @@ __export(src_exports, {
   merkle: () => merkle_exports,
   num: () => num_exports,
   number: () => number,
+  parseCalldataField: () => parseCalldataField,
   parseUDCEvent: () => parseUDCEvent,
   provider: () => provider_exports,
   selector: () => selector_exports,
@@ -141,7 +142,7 @@ __export(constants_exports, {
   RPC_NODES: () => RPC_NODES,
   StarknetChainId: () => StarknetChainId,
   TEXT_TO_FELT_MAX_LEN: () => TEXT_TO_FELT_MAX_LEN,
-  TRANSACTION_VERSION: () => ETransactionVersion4,
+  TRANSACTION_VERSION: () => api_exports.ETransactionVersion,
   TransactionHashPrefix: () => TransactionHashPrefix,
   UDC: () => UDC,
   ZERO: () => ZERO,
@@ -151,22 +152,9 @@ __export(constants_exports, {
 // src/types/api/index.ts
 var api_exports = {};
 __export(api_exports, {
-  EBlockTag: () => EBlockTag2,
-  EDAMode: () => EDAMode2,
-  EDataAvailabilityMode: () => EDataAvailabilityMode2,
-  ESimulationFlag: () => ESimulationFlag2,
-  ETransactionExecutionStatus: () => ETransactionExecutionStatus2,
-  ETransactionFinalityStatus: () => ETransactionFinalityStatus2,
-  ETransactionStatus: () => ETransactionStatus2,
-  ETransactionType: () => ETransactionType2,
-  ETransactionVersion: () => ETransactionVersion4,
-  ETransactionVersion2: () => ETransactionVersion22,
-  ETransactionVersion3: () => ETransactionVersion32,
-  Errors: () => errors_exports2,
   JRPC: () => jsonrpc_exports,
   RPCSPEC06: () => rpcspec_0_6_exports,
-  RPCSPEC07: () => rpcspec_0_7_exports,
-  SPEC: () => components_exports2
+  RPCSPEC07: () => RPCSPEC07
 });
 
 // src/types/api/jsonrpc/index.ts
@@ -197,40 +185,40 @@ var errors_exports = {};
 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;
+var ETransactionType = /* @__PURE__ */ ((ETransactionType2) => {
+  ETransactionType2["DECLARE"] = "DECLARE";
+  ETransactionType2["DEPLOY"] = "DEPLOY";
+  ETransactionType2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
+  ETransactionType2["INVOKE"] = "INVOKE";
+  ETransactionType2["L1_HANDLER"] = "L1_HANDLER";
+  return ETransactionType2;
 })(ETransactionType || {});
-var ESimulationFlag = /* @__PURE__ */ ((ESimulationFlag3) => {
-  ESimulationFlag3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-  ESimulationFlag3["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
-  return ESimulationFlag3;
+var ESimulationFlag = /* @__PURE__ */ ((ESimulationFlag2) => {
+  ESimulationFlag2["SKIP_VALIDATE"] = "SKIP_VALIDATE";
+  ESimulationFlag2["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
+  return ESimulationFlag2;
 })(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;
+var ETransactionStatus = /* @__PURE__ */ ((ETransactionStatus2) => {
+  ETransactionStatus2["RECEIVED"] = "RECEIVED";
+  ETransactionStatus2["REJECTED"] = "REJECTED";
+  ETransactionStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+  ETransactionStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+  return ETransactionStatus2;
 })(ETransactionStatus || {});
-var ETransactionFinalityStatus = /* @__PURE__ */ ((ETransactionFinalityStatus3) => {
-  ETransactionFinalityStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  ETransactionFinalityStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  return ETransactionFinalityStatus3;
+var ETransactionFinalityStatus = /* @__PURE__ */ ((ETransactionFinalityStatus2) => {
+  ETransactionFinalityStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+  ETransactionFinalityStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+  return ETransactionFinalityStatus2;
 })(ETransactionFinalityStatus || {});
-var ETransactionExecutionStatus = /* @__PURE__ */ ((ETransactionExecutionStatus3) => {
-  ETransactionExecutionStatus3["SUCCEEDED"] = "SUCCEEDED";
-  ETransactionExecutionStatus3["REVERTED"] = "REVERTED";
-  return ETransactionExecutionStatus3;
+var ETransactionExecutionStatus = /* @__PURE__ */ ((ETransactionExecutionStatus2) => {
+  ETransactionExecutionStatus2["SUCCEEDED"] = "SUCCEEDED";
+  ETransactionExecutionStatus2["REVERTED"] = "REVERTED";
+  return ETransactionExecutionStatus2;
 })(ETransactionExecutionStatus || {});
-var EBlockTag = /* @__PURE__ */ ((EBlockTag3) => {
-  EBlockTag3["LATEST"] = "latest";
-  EBlockTag3["PENDING"] = "pending";
-  return EBlockTag3;
+var EBlockTag = /* @__PURE__ */ ((EBlockTag2) => {
+  EBlockTag2["LATEST"] = "latest";
+  EBlockTag2["PENDING"] = "pending";
+  return EBlockTag2;
 })(EBlockTag || {});
 var EDataAvailabilityMode = /* @__PURE__ */ ((EDataAvailabilityMode3) => {
   EDataAvailabilityMode3["L1"] = "L1";
@@ -242,127 +230,35 @@ var EDAMode = /* @__PURE__ */ ((EDAMode4) => {
   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;
+var ETransactionVersion = /* @__PURE__ */ ((ETransactionVersion10) => {
+  ETransactionVersion10["V0"] = "0x0";
+  ETransactionVersion10["V1"] = "0x1";
+  ETransactionVersion10["V2"] = "0x2";
+  ETransactionVersion10["V3"] = "0x3";
+  ETransactionVersion10["F0"] = "0x100000000000000000000000000000000";
+  ETransactionVersion10["F1"] = "0x100000000000000000000000000000001";
+  ETransactionVersion10["F2"] = "0x100000000000000000000000000000002";
+  ETransactionVersion10["F3"] = "0x100000000000000000000000000000003";
+  return ETransactionVersion10;
 })(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;
+var ETransactionVersion2 = /* @__PURE__ */ ((ETransactionVersion25) => {
+  ETransactionVersion25["V0"] = "0x0";
+  ETransactionVersion25["V1"] = "0x1";
+  ETransactionVersion25["V2"] = "0x2";
+  ETransactionVersion25["F0"] = "0x100000000000000000000000000000000";
+  ETransactionVersion25["F1"] = "0x100000000000000000000000000000001";
+  ETransactionVersion25["F2"] = "0x100000000000000000000000000000002";
+  return ETransactionVersion25;
 })(ETransactionVersion2 || {});
-var ETransactionVersion3 = /* @__PURE__ */ ((ETransactionVersion34) => {
-  ETransactionVersion34["V3"] = "0x3";
-  ETransactionVersion34["F3"] = "0x100000000000000000000000000000003";
-  return ETransactionVersion34;
+var ETransactionVersion3 = /* @__PURE__ */ ((ETransactionVersion36) => {
+  ETransactionVersion36["V3"] = "0x3";
+  ETransactionVersion36["F3"] = "0x100000000000000000000000000000003";
+  return ETransactionVersion36;
 })(ETransactionVersion3 || {});
 
-// src/types/api/rpcspec_0_7/index.ts
-var rpcspec_0_7_exports = {};
-__export(rpcspec_0_7_exports, {
-  EBlockTag: () => EBlockTag2,
-  EDAMode: () => EDAMode2,
-  EDataAvailabilityMode: () => EDataAvailabilityMode2,
-  ESimulationFlag: () => ESimulationFlag2,
-  ETransactionExecutionStatus: () => ETransactionExecutionStatus2,
-  ETransactionFinalityStatus: () => ETransactionFinalityStatus2,
-  ETransactionStatus: () => ETransactionStatus2,
-  ETransactionType: () => ETransactionType2,
-  ETransactionVersion: () => ETransactionVersion4,
-  ETransactionVersion2: () => ETransactionVersion22,
-  ETransactionVersion3: () => ETransactionVersion32,
-  Errors: () => errors_exports2,
-  SPEC: () => components_exports2
-});
-
-// src/types/api/rpcspec_0_7/errors.ts
-var errors_exports2 = {};
-
-// src/types/api/rpcspec_0_7/components.ts
-var components_exports2 = {};
-
-// src/types/api/rpcspec_0_7/nonspec.ts
-var ETransactionType2 = /* @__PURE__ */ ((ETransactionType3) => {
-  ETransactionType3["DECLARE"] = "DECLARE";
-  ETransactionType3["DEPLOY"] = "DEPLOY";
-  ETransactionType3["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-  ETransactionType3["INVOKE"] = "INVOKE";
-  ETransactionType3["L1_HANDLER"] = "L1_HANDLER";
-  return ETransactionType3;
-})(ETransactionType2 || {});
-var ESimulationFlag2 = /* @__PURE__ */ ((ESimulationFlag3) => {
-  ESimulationFlag3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-  ESimulationFlag3["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
-  return ESimulationFlag3;
-})(ESimulationFlag2 || {});
-var ETransactionStatus2 = /* @__PURE__ */ ((ETransactionStatus3) => {
-  ETransactionStatus3["RECEIVED"] = "RECEIVED";
-  ETransactionStatus3["REJECTED"] = "REJECTED";
-  ETransactionStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  ETransactionStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  return ETransactionStatus3;
-})(ETransactionStatus2 || {});
-var ETransactionFinalityStatus2 = /* @__PURE__ */ ((ETransactionFinalityStatus3) => {
-  ETransactionFinalityStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  ETransactionFinalityStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  return ETransactionFinalityStatus3;
-})(ETransactionFinalityStatus2 || {});
-var ETransactionExecutionStatus2 = /* @__PURE__ */ ((ETransactionExecutionStatus3) => {
-  ETransactionExecutionStatus3["SUCCEEDED"] = "SUCCEEDED";
-  ETransactionExecutionStatus3["REVERTED"] = "REVERTED";
-  return ETransactionExecutionStatus3;
-})(ETransactionExecutionStatus2 || {});
-var EBlockTag2 = /* @__PURE__ */ ((EBlockTag3) => {
-  EBlockTag3["LATEST"] = "latest";
-  EBlockTag3["PENDING"] = "pending";
-  return EBlockTag3;
-})(EBlockTag2 || {});
-var EDataAvailabilityMode2 = /* @__PURE__ */ ((EDataAvailabilityMode3) => {
-  EDataAvailabilityMode3["L1"] = "L1";
-  EDataAvailabilityMode3["L2"] = "L2";
-  return EDataAvailabilityMode3;
-})(EDataAvailabilityMode2 || {});
-var EDAMode2 = /* @__PURE__ */ ((EDAMode4) => {
-  EDAMode4[EDAMode4["L1"] = 0] = "L1";
-  EDAMode4[EDAMode4["L2"] = 1] = "L2";
-  return EDAMode4;
-})(EDAMode2 || {});
-var ETransactionVersion4 = /* @__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;
-})(ETransactionVersion4 || {});
-var ETransactionVersion22 = /* @__PURE__ */ ((ETransactionVersion24) => {
-  ETransactionVersion24["V0"] = "0x0";
-  ETransactionVersion24["V1"] = "0x1";
-  ETransactionVersion24["V2"] = "0x2";
-  ETransactionVersion24["F0"] = "0x100000000000000000000000000000000";
-  ETransactionVersion24["F1"] = "0x100000000000000000000000000000001";
-  ETransactionVersion24["F2"] = "0x100000000000000000000000000000002";
-  return ETransactionVersion24;
-})(ETransactionVersion22 || {});
-var ETransactionVersion32 = /* @__PURE__ */ ((ETransactionVersion34) => {
-  ETransactionVersion34["V3"] = "0x3";
-  ETransactionVersion34["F3"] = "0x100000000000000000000000000000003";
-  return ETransactionVersion34;
-})(ETransactionVersion32 || {});
+// src/types/api/index.ts
+var RPCSPEC07 = __toESM(require("starknet-types-07"));
+__reExport(api_exports, require("starknet-types-07"));
 
 // src/utils/encode.ts
 var encode_exports = {};
@@ -453,19 +349,16 @@ 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_GOERLI"] = "https://alpha4.starknet.io";
   BaseUrl2["SN_SEPOLIA"] = "https://alpha-sepolia.starknet.io";
   return BaseUrl2;
 })(BaseUrl || {});
 var NetworkName = /* @__PURE__ */ ((NetworkName2) => {
   NetworkName2["SN_MAIN"] = "SN_MAIN";
-  NetworkName2["SN_GOERLI"] = "SN_GOERLI";
   NetworkName2["SN_SEPOLIA"] = "SN_SEPOLIA";
   return NetworkName2;
 })(NetworkName || {});
 var StarknetChainId = /* @__PURE__ */ ((StarknetChainId6) => {
   StarknetChainId6["SN_MAIN"] = "0x534e5f4d41494e";
-  StarknetChainId6["SN_GOERLI"] = "0x534e5f474f45524c49";
   StarknetChainId6["SN_SEPOLIA"] = "0x534e5f5345504f4c4941";
   return StarknetChainId6;
 })(StarknetChainId || {});
@@ -489,10 +382,6 @@ var UDC = {
 };
 var RPC_DEFAULT_VERSION = "v0_7";
 var RPC_NODES = {
-  SN_GOERLI: [
-    `https://starknet-testnet.public.blastapi.io/rpc/${RPC_DEFAULT_VERSION}`,
-    `https://free-rpc.nethermind.io/goerli-juno/${RPC_DEFAULT_VERSION}`
-  ],
   SN_MAIN: [
     `https://starknet-mainnet.public.blastapi.io/rpc/${RPC_DEFAULT_VERSION}`,
     `https://free-rpc.nethermind.io/mainnet-juno/${RPC_DEFAULT_VERSION}`
@@ -503,6 +392,16 @@ var RPC_NODES = {
   ]
 };
 
+// src/provider/rpc.ts
+var import_utils2 = require("@noble/curves/abstract/utils");
+var import_sha3 = require("@noble/hashes/sha3");
+
+// src/channel/rpc_0_6.ts
+var rpc_0_6_exports = {};
+__export(rpc_0_6_exports, {
+  RpcChannel: () => RpcChannel
+});
+
 // src/provider/errors.ts
 function fixStack(target, fn = target.constructor) {
   const { captureStackTrace } = Error;
@@ -540,12 +439,6 @@ var HttpError = class extends LibraryError {
   }
 };
 
-// src/channel/rpc_0_6.ts
-var rpc_0_6_exports = {};
-__export(rpc_0_6_exports, {
-  RpcChannel: () => RpcChannel
-});
-
 // src/types/index.ts
 var types_exports = {};
 __export(types_exports, {
@@ -554,23 +447,15 @@ __export(types_exports, {
   EntryPointType: () => EntryPointType,
   Literal: () => Literal,
   RPC: () => api_exports,
-  SIMULATION_FLAG: () => SIMULATION_FLAG,
   TransactionExecutionStatus: () => TransactionExecutionStatus,
   TransactionFinalityStatus: () => TransactionFinalityStatus,
   TransactionStatus: () => TransactionStatus,
   TransactionType: () => TransactionType,
-  TypedDataRevision: () => import_starknet_types.TypedDataRevision,
+  TypedDataRevision: () => import_starknet_types_07.TypedDataRevision,
   Uint: () => Uint,
   ValidateType: () => ValidateType
 });
 
-// src/types/account.ts
-var SIMULATION_FLAG = /* @__PURE__ */ ((SIMULATION_FLAG2) => {
-  SIMULATION_FLAG2["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-  SIMULATION_FLAG2["SKIP_EXECUTE"] = "SKIP_EXECUTE";
-  return SIMULATION_FLAG2;
-})(SIMULATION_FLAG || {});
-
 // src/types/calldata.ts
 var ValidateType = /* @__PURE__ */ ((ValidateType2) => {
   ValidateType2["DEPLOY"] = "DEPLOY";
@@ -647,7 +532,7 @@ var BlockTag = /* @__PURE__ */ ((BlockTag2) => {
 })(BlockTag || {});
 
 // src/types/typedData.ts
-var import_starknet_types = require("starknet-types");
+var import_starknet_types_07 = require("starknet-types-07");
 
 // src/utils/assert.ts
 function assert(condition, message) {
@@ -1389,46 +1274,49 @@ var guard = {
   }
 };
 function formatter(data, type, sameType) {
-  return Object.entries(data).reduce((acc, [key, value]) => {
-    const elType = sameType ?? type[key];
-    if (!(key in type) && !sameType) {
-      acc[key] = value;
-      return acc;
-    }
-    if (elType === "string") {
-      if (Array.isArray(data[key])) {
-        const arrayStr = formatter(
-          data[key],
-          data[key].map((_) => elType)
-        );
-        acc[key] = Object.values(arrayStr).join("");
+  return Object.entries(data).reduce(
+    (acc, [key, value]) => {
+      const elType = sameType ?? type[key];
+      if (!(key in type) && !sameType) {
+        acc[key] = value;
         return acc;
       }
-      guard.isBN(data, type, key);
-      acc[key] = decodeShortString(value);
-      return acc;
-    }
-    if (elType === "number") {
-      guard.isBN(data, type, key);
-      acc[key] = Number(value);
-      return acc;
-    }
-    if (typeof elType === "function") {
-      acc[key] = elType(value);
-      return acc;
-    }
-    if (Array.isArray(elType)) {
-      const arrayObj = formatter(data[key], elType, elType[0]);
-      acc[key] = Object.values(arrayObj);
-      return acc;
-    }
-    if (typeof elType === "object") {
-      acc[key] = formatter(data[key], elType);
+      if (elType === "string") {
+        if (Array.isArray(data[key])) {
+          const arrayStr = formatter(
+            data[key],
+            data[key].map((_) => elType)
+          );
+          acc[key] = Object.values(arrayStr).join("");
+          return acc;
+        }
+        guard.isBN(data, type, key);
+        acc[key] = decodeShortString(value);
+        return acc;
+      }
+      if (elType === "number") {
+        guard.isBN(data, type, key);
+        acc[key] = Number(value);
+        return acc;
+      }
+      if (typeof elType === "function") {
+        acc[key] = elType(value);
+        return acc;
+      }
+      if (Array.isArray(elType)) {
+        const arrayObj = formatter(data[key], elType, elType[0]);
+        acc[key] = Object.values(arrayObj);
+        return acc;
+      }
+      if (typeof elType === "object") {
+        acc[key] = formatter(data[key], elType);
+        return acc;
+      }
+      guard.unknown(data, type, key);
       return acc;
-    }
-    guard.unknown(data, type, key);
-    return acc;
-  }, {});
+    },
+    {}
+  );
 }
 
 // src/utils/calldata/parser/parser-0-1.1.0.ts
@@ -1483,7 +1371,9 @@ var AbiParser2 = class {
    * @returns FunctionAbi | undefined
    */
   getMethod(name) {
-    const intf = this.abi.find((it) => it.type === "interface");
+    const intf = this.abi.find(
+      (it) => it.type === "interface"
+    );
     return intf.items.find((it) => it.name === name);
   }
   /**
@@ -2453,7 +2343,7 @@ var CallData = class _CallData {
    * Compile contract callData with abi
    * Parse the calldata by using input fields from the abi for that method
    * @param method string - method name
-   * @param args RawArgs - arguments passed to the method. Can be an array of arguments (in the order of abi definition), or an object constructed in conformity with abi (in this case, the parameter can be in a wrong order).
+   * @param argsCalldata RawArgs - arguments passed to the method. Can be an array of arguments (in the order of abi definition), or an object constructed in conformity with abi (in this case, the parameter can be in a wrong order).
    * @return Calldata - parsed arguments in format that contract is expecting
    * @example
    * ```typescript
@@ -2855,7 +2745,7 @@ function calculateInvokeTransactionHash(senderAddress, version, compiledCalldata
 
 // src/utils/hash/transactionHash/index.ts
 function isV3InvokeTx(args) {
-  return ["0x3" /* V3 */, "0x100000000000000000000000000000003" /* F3 */].includes(
+  return [api_exports.ETransactionVersion.V3, api_exports.ETransactionVersion.F3].includes(
     args.version
   );
 }
@@ -2885,7 +2775,7 @@ function calculateInvokeTransactionHash2(args) {
   );
 }
 function isV3DeclareTx(args) {
-  return ["0x3" /* V3 */, "0x100000000000000000000000000000003" /* F3 */].includes(
+  return [api_exports.ETransactionVersion.V3, api_exports.ETransactionVersion.F3].includes(
     args.version
   );
 }
@@ -2917,7 +2807,7 @@ function calculateDeclareTransactionHash3(args) {
   );
 }
 function isV3DeployAccountTx(args) {
-  return ["0x3" /* V3 */, "0x100000000000000000000000000000003" /* F3 */].includes(
+  return [api_exports.ETransactionVersion.V3, api_exports.ETransactionVersion.F3].includes(
     args.version
   );
 }
@@ -3212,19 +3102,19 @@ function estimateFeeToBounds(estimate, amountOverhead = 50 /* L1_BOUND_MAX_AMOUN
   };
 }
 function intDAM(dam) {
-  if (dam === "L1" /* L1 */)
-    return 0 /* L1 */;
-  if (dam === "L2" /* L2 */)
-    return 1 /* L2 */;
+  if (dam === api_exports.EDataAvailabilityMode.L1)
+    return api_exports.EDAMode.L1;
+  if (dam === api_exports.EDataAvailabilityMode.L2)
+    return api_exports.EDAMode.L2;
   throw Error("EDAM conversion");
 }
 function toTransactionVersion(defaultVersion, providedVersion) {
   const providedVersion0xs = providedVersion ? toHex(providedVersion) : void 0;
   const defaultVersion0xs = toHex(defaultVersion);
-  if (providedVersion && !Object.values(ETransactionVersion4).includes(providedVersion0xs)) {
+  if (providedVersion && !Object.values(api_exports.ETransactionVersion).includes(providedVersion0xs)) {
     throw Error(`providedVersion ${providedVersion} is not ETransactionVersion`);
   }
-  if (!Object.values(ETransactionVersion4).includes(defaultVersion0xs)) {
+  if (!Object.values(api_exports.ETransactionVersion).includes(defaultVersion0xs)) {
     throw Error(`defaultVersion ${defaultVersion} is not ETransactionVersion`);
   }
   return providedVersion ? providedVersion0xs : defaultVersion0xs;
@@ -3233,14 +3123,14 @@ function toFeeVersion(providedVersion) {
   if (!providedVersion)
     return void 0;
   const version = toHex(providedVersion);
-  if (version === "0x0" /* V0 */)
-    return "0x100000000000000000000000000000000" /* F0 */;
-  if (version === "0x1" /* V1 */)
-    return "0x100000000000000000000000000000001" /* F1 */;
-  if (version === "0x2" /* V2 */)
-    return "0x100000000000000000000000000000002" /* F2 */;
-  if (version === "0x3" /* V3 */)
-    return "0x100000000000000000000000000000003" /* F3 */;
+  if (version === api_exports.ETransactionVersion.V0)
+    return api_exports.ETransactionVersion.F0;
+  if (version === api_exports.ETransactionVersion.V1)
+    return api_exports.ETransactionVersion.F1;
+  if (version === api_exports.ETransactionVersion.V2)
+    return api_exports.ETransactionVersion.F2;
+  if (version === api_exports.ETransactionVersion.V3)
+    return api_exports.ETransactionVersion.F3;
   throw Error(`toFeeVersion: ${version} is not supported`);
 }
 function v3Details(details) {
@@ -3248,16 +3138,16 @@ function v3Details(details) {
     tip: details.tip || 0,
     paymasterData: details.paymasterData || [],
     accountDeploymentData: details.accountDeploymentData || [],
-    nonceDataAvailabilityMode: details.nonceDataAvailabilityMode || "L1" /* L1 */,
-    feeDataAvailabilityMode: details.feeDataAvailabilityMode || "L1" /* L1 */,
+    nonceDataAvailabilityMode: details.nonceDataAvailabilityMode || api_exports.EDataAvailabilityMode.L1,
+    feeDataAvailabilityMode: details.feeDataAvailabilityMode || api_exports.EDataAvailabilityMode.L1,
     resourceBounds: details.resourceBounds ?? estimateFeeToBounds(ZERO)
   };
 }
 function reduceV2(providedVersion) {
-  if (providedVersion === "0x100000000000000000000000000000002" /* F2 */)
-    return "0x100000000000000000000000000000001" /* F1 */;
-  if (providedVersion === "0x2" /* V2 */)
-    return "0x1" /* V1 */;
+  if (providedVersion === api_exports.ETransactionVersion.F2)
+    return api_exports.ETransactionVersion.F1;
+  if (providedVersion === api_exports.ETransactionVersion.V2)
+    return api_exports.ETransactionVersion.V1;
   return providedVersion;
 }
 
@@ -3303,7 +3193,7 @@ function ethRandomPrivateKey() {
 function validateAndParseEthAddress(address) {
   assertInRange(address, ZERO, 2n ** 160n - 1n, "Ethereum Address ");
   const result = addHexPrefix(removeHexPrefix(toHex(address)).padStart(40, "0"));
-  assert(result.match(/^(0x)?[0-9a-f]{40}$/), "Invalid Ethereum Address Format");
+  assert(Boolean(result.match(/^(0x)?[0-9a-f]{40}$/)), "Invalid Ethereum Address Format");
   return result;
 }
 
@@ -3355,9 +3245,10 @@ function parseContract(contract) {
   return createSierraContractClass(parsedContract);
 }
 var getDefaultNodeUrl = (networkName, mute = false) => {
-  if (!mute)
+  if (!mute) {
     console.warn("Using default public node url, please provide nodeUrl in provider options!");
-  const nodes = RPC_NODES[networkName ?? "SN_GOERLI" /* SN_GOERLI */];
+  }
+  const nodes = RPC_NODES[networkName ?? "SN_SEPOLIA" /* SN_SEPOLIA */];
   const randIdx = Math.floor(Math.random() * nodes.length);
   return nodes[randIdx];
 };
@@ -3380,10 +3271,14 @@ var Block = class {
   tag = null;
   setIdentifier(__identifier) {
     if (isString(__identifier)) {
-      if (isHex(__identifier)) {
+      if (isDecimalString(__identifier)) {
+        this.number = parseInt(__identifier, 10);
+      } else if (isHex(__identifier)) {
         this.hash = __identifier;
       } else if (validBlockTags.includes(__identifier)) {
         this.tag = __identifier;
+      } else {
+        throw TypeError(`Block identifier unmanaged: ${__identifier}`);
       }
     } else if (isBigInt(__identifier)) {
       this.hash = toHex(__identifier);
@@ -3392,6 +3287,9 @@ var Block = class {
     } else {
       this.tag = "pending" /* pending */;
     }
+    if (isNumber(this.number) && this.number < 0) {
+      throw TypeError(`Block number (${this.number}) can't be negative`);
+    }
   }
   constructor(_identifier) {
     this.setIdentifier(_identifier);
@@ -3421,15 +3319,10 @@ var Block = class {
   }
   valueOf = () => this.number;
   toString = () => this.hash;
-  /*   get sequencerIdentifier(): SequencerIdentifier {
-    return this.hash !== null
-      ? { blockHash: this.hash as string }
-      : { blockNumber: (this.number ?? this.tag) as BlockNumber };
-  } */
 };
 function isV3Tx(details) {
-  const version = details.version ? toHex(details.version) : "0x3" /* V3 */;
-  return version === "0x3" /* V3 */ || version === "0x100000000000000000000000000000003" /* F3 */;
+  const version = details.version ? toHex(details.version) : api_exports.ETransactionVersion.V3;
+  return version === api_exports.ETransactionVersion.V3 || version === api_exports.ETransactionVersion.F3;
 }
 function isVersion(version, response) {
   const [majorS, minorS] = version.split(".");
@@ -3544,10 +3437,10 @@ function buildUDCCall(payload, address) {
 }
 function getVersionsByType(versionType) {
   return versionType === "fee" ? {
-    v1: "0x100000000000000000000000000000001" /* F1 */,
-    v2: "0x100000000000000000000000000000002" /* F2 */,
-    v3: "0x100000000000000000000000000000003" /* F3 */
-  } : { v1: "0x1" /* V1 */, v2: "0x2" /* V2 */, v3: "0x3" /* V3 */ };
+    v1: api_exports.ETransactionVersion.F1,
+    v2: api_exports.ETransactionVersion.F2,
+    v3: api_exports.ETransactionVersion.F3
+  } : { v1: api_exports.ETransactionVersion.V1, v2: api_exports.ETransactionVersion.V2, v3: api_exports.ETransactionVersion.V3 };
 }
 
 // src/channel/rpc_0_6.ts
@@ -3708,11 +3601,12 @@ var RpcChannel = class {
    * - skipValidate (default false)<br/>
    * - skipFeeCharge (default true)<br/>
    */
-  simulateTransaction(invocations, {
-    blockIdentifier = this.blockIdentifier,
-    skipValidate = true,
-    skipFeeCharge = true
-  } = {}) {
+  simulateTransaction(invocations, simulateTransactionOptions = {}) {
+    const {
+      blockIdentifier = this.blockIdentifier,
+      skipValidate = true,
+      skipFeeCharge = true
+    } = simulateTransactionOptions;
     const block_id = new Block(blockIdentifier).identifier;
     const simulationFlags = [];
     if (skipValidate)
@@ -4035,7 +3929,6 @@ var RpcChannel = class {
       return {
         // v0 v1 v3
         type: rpcspec_0_6_exports.ETransactionType.INVOKE,
-        // TODO: Diff between sequencer and rpc invoke type
         sender_address: invocation.contractAddress,
         calldata: CallData.toHex(invocation.calldata),
         version: toHex(invocation.version || defaultVersions.v3),
@@ -4098,10 +3991,20 @@ var RpcChannel2 = class {
   blockIdentifier;
   chainId;
   specVersion;
+  transactionRetryIntervalFallback;
   waitMode;
   // behave like web2 rpc and return when tx is processed
   constructor(optionsOrProvider) {
-    const { nodeUrl, retries, headers, blockIdentifier, chainId, specVersion, waitMode } = optionsOrProvider || {};
+    const {
+      nodeUrl,
+      retries,
+      headers,
+      blockIdentifier,
+      chainId,
+      specVersion,
+      waitMode,
+      transactionRetryIntervalFallback
+    } = optionsOrProvider || {};
     if (Object.values(NetworkName).includes(nodeUrl)) {
       this.nodeUrl = getDefaultNodeUrl(nodeUrl, optionsOrProvider?.default);
     } else if (nodeUrl) {
@@ -4116,6 +4019,10 @@ var RpcChannel2 = class {
     this.specVersion = specVersion;
     this.waitMode = waitMode || false;
     this.requestId = 0;
+    this.transactionRetryIntervalFallback = transactionRetryIntervalFallback;
+  }
+  get transactionRetryIntervalDefault() {
+    return this.transactionRetryIntervalFallback ?? 5e3;
   }
   setChainId(chainId) {
     this.chainId = chainId;
@@ -4246,17 +4153,18 @@ var RpcChannel2 = class {
    * - skipValidate (default false)<br/>
    * - skipFeeCharge (default true)<br/>
    */
-  simulateTransaction(invocations, {
-    blockIdentifier = this.blockIdentifier,
-    skipValidate = true,
-    skipFeeCharge = true
-  } = {}) {
+  simulateTransaction(invocations, simulateTransactionOptions = {}) {
+    const {
+      blockIdentifier = this.blockIdentifier,
+      skipValidate = true,
+      skipFeeCharge = true
+    } = simulateTransactionOptions;
     const block_id = new Block(blockIdentifier).identifier;
     const simulationFlags = [];
     if (skipValidate)
-      simulationFlags.push(rpcspec_0_7_exports.ESimulationFlag.SKIP_VALIDATE);
+      simulationFlags.push(RPCSPEC07.ESimulationFlag.SKIP_VALIDATE);
     if (skipFeeCharge)
-      simulationFlags.push(rpcspec_0_7_exports.ESimulationFlag.SKIP_FEE_CHARGE);
+      simulationFlags.push(RPCSPEC07.ESimulationFlag.SKIP_FEE_CHARGE);
     return this.fetchEndpoint("starknet_simulateTransactions", {
       block_id,
       transactions: invocations.map((it) => this.buildTransaction(it)),
@@ -4268,17 +4176,17 @@ var RpcChannel2 = class {
     let { retries } = this;
     let onchain = false;
     let isErrorState = false;
-    const retryInterval = options?.retryInterval ?? 5e3;
+    const retryInterval = options?.retryInterval ?? this.transactionRetryIntervalDefault;
     const errorStates = options?.errorStates ?? [
-      rpcspec_0_7_exports.ETransactionStatus.REJECTED
+      RPCSPEC07.ETransactionStatus.REJECTED
       // TODO: commented out to preserve the long-standing behavior of "reverted" not being treated as an error by default
       // should decide which behavior to keep in the future
       // RPC.ETransactionExecutionStatus.REVERTED,
     ];
     const successStates = options?.successStates ?? [
-      rpcspec_0_7_exports.ETransactionExecutionStatus.SUCCEEDED,
-      rpcspec_0_7_exports.ETransactionStatus.ACCEPTED_ON_L2,
-      rpcspec_0_7_exports.ETransactionStatus.ACCEPTED_ON_L1
+      RPCSPEC07.ETransactionExecutionStatus.SUCCEEDED,
+      RPCSPEC07.ETransactionStatus.ACCEPTED_ON_L2,
+      RPCSPEC07.ETransactionStatus.ACCEPTED_ON_L1
     ];
     let txStatus;
     while (!onchain) {
@@ -4363,7 +4271,7 @@ var RpcChannel2 = class {
     let flags = {};
     if (!isVersion("0.5", await this.getSpecVersion())) {
       flags = {
-        simulation_flags: skipValidate ? [rpcspec_0_7_exports.ESimulationFlag.SKIP_VALIDATE] : []
+        simulation_flags: skipValidate ? [RPCSPEC07.ESimulationFlag.SKIP_VALIDATE] : []
       };
     }
     return this.fetchEndpoint("starknet_estimateFee", {
@@ -4379,9 +4287,9 @@ var RpcChannel2 = class {
         invoke_transaction: {
           sender_address: functionInvocation.contractAddress,
           calldata: CallData.toHex(functionInvocation.calldata),
-          type: rpcspec_0_7_exports.ETransactionType.INVOKE,
+          type: RPCSPEC07.ETransactionType.INVOKE,
           max_fee: toHex(details.maxFee || 0),
-          version: rpcspec_0_7_exports.ETransactionVersion.V1,
+          version: RPCSPEC07.ETransactionVersion.V1,
           signature: signatureToHexArray(functionInvocation.signature),
           nonce: toHex(details.nonce)
         }
@@ -4389,10 +4297,10 @@ var RpcChannel2 = class {
     } else {
       promise = this.fetchEndpoint("starknet_addInvokeTransaction", {
         invoke_transaction: {
-          type: rpcspec_0_7_exports.ETransactionType.INVOKE,
+          type: RPCSPEC07.ETransactionType.INVOKE,
           sender_address: functionInvocation.contractAddress,
           calldata: CallData.toHex(functionInvocation.calldata),
-          version: rpcspec_0_7_exports.ETransactionVersion.V3,
+          version: RPCSPEC07.ETransactionVersion.V3,
           signature: signatureToHexArray(functionInvocation.signature),
           nonce: toHex(details.nonce),
           resource_bounds: details.resourceBounds,
@@ -4411,13 +4319,13 @@ var RpcChannel2 = class {
     if (!isSierra(contract) && !isV3Tx(details)) {
       promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
         declare_transaction: {
-          type: rpcspec_0_7_exports.ETransactionType.DECLARE,
+          type: RPCSPEC07.ETransactionType.DECLARE,
           contract_class: {
             program: contract.program,
             entry_points_by_type: contract.entry_points_by_type,
             abi: contract.abi
           },
-          version: rpcspec_0_7_exports.ETransactionVersion.V1,
+          version: RPCSPEC07.ETransactionVersion.V1,
           max_fee: toHex(details.maxFee || 0),
           signature: signatureToHexArray(signature),
           sender_address: senderAddress,
@@ -4427,7 +4335,7 @@ var RpcChannel2 = class {
     } else if (isSierra(contract) && !isV3Tx(details)) {
       promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
         declare_transaction: {
-          type: rpcspec_0_7_exports.ETransactionType.DECLARE,
+          type: RPCSPEC07.ETransactionType.DECLARE,
           contract_class: {
             sierra_program: decompressProgram(contract.sierra_program),
             contract_class_version: contract.contract_class_version,
@@ -4435,7 +4343,7 @@ var RpcChannel2 = class {
             abi: contract.abi
           },
           compiled_class_hash: compiledClassHash || "",
-          version: rpcspec_0_7_exports.ETransactionVersion.V2,
+          version: RPCSPEC07.ETransactionVersion.V2,
           max_fee: toHex(details.maxFee || 0),
           signature: signatureToHexArray(signature),
           sender_address: senderAddress,
@@ -4445,10 +4353,10 @@ var RpcChannel2 = class {
     } else if (isSierra(contract) && isV3Tx(details)) {
       promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
         declare_transaction: {
-          type: rpcspec_0_7_exports.ETransactionType.DECLARE,
+          type: RPCSPEC07.ETransactionType.DECLARE,
           sender_address: senderAddress,
           compiled_class_hash: compiledClassHash || "",
-          version: rpcspec_0_7_exports.ETransactionVersion.V3,
+          version: RPCSPEC07.ETransactionVersion.V3,
           signature: signatureToHexArray(signature),
           nonce: toHex(details.nonce),
           contract_class: {
@@ -4478,9 +4386,9 @@ var RpcChannel2 = class {
           constructor_calldata: CallData.toHex(constructorCalldata || []),
           class_hash: toHex(classHash),
           contract_address_salt: toHex(addressSalt || 0),
-          type: rpcspec_0_7_exports.ETransactionType.DEPLOY_ACCOUNT,
+          type: RPCSPEC07.ETransactionType.DEPLOY_ACCOUNT,
           max_fee: toHex(details.maxFee || 0),
-          version: rpcspec_0_7_exports.ETransactionVersion.V1,
+          version: RPCSPEC07.ETransactionVersion.V1,
           signature: signatureToHexArray(signature),
           nonce: toHex(details.nonce)
         }
@@ -4488,8 +4396,8 @@ var RpcChannel2 = class {
     } else {
       promise = this.fetchEndpoint("starknet_addDeployAccountTransaction", {
         deploy_account_transaction: {
-          type: rpcspec_0_7_exports.ETransactionType.DEPLOY_ACCOUNT,
-          version: rpcspec_0_7_exports.ETransactionVersion.V3,
+          type: RPCSPEC07.ETransactionType.DEPLOY_ACCOUNT,
+          version: RPCSPEC07.ETransactionVersion.V3,
           signature: signatureToHexArray(signature),
           nonce: toHex(details.nonce),
           contract_address_salt: toHex(addressSalt || 0),
@@ -4572,8 +4480,7 @@ var RpcChannel2 = class {
     if (invocation.type === "INVOKE_FUNCTION" /* INVOKE */) {
       return {
         // v0 v1 v3
-        type: rpcspec_0_7_exports.ETransactionType.INVOKE,
-        // TODO: Diff between sequencer and rpc invoke type
+        type: RPCSPEC07.ETransactionType.INVOKE,
         sender_address: invocation.contractAddress,
         calldata: CallData.toHex(invocation.calldata),
         version: toHex(invocation.version || defaultVersions.v3),
@@ -4689,6 +4596,9 @@ var RPCResponseParser = class {
       abi: isString(res.abi) ? JSON.parse(res.abi) : res.abi
     };
   }
+  parseL1GasPriceResponse(res) {
+    return res.l1_gas_price.price_in_wei;
+  }
 };
 
 // src/utils/transactionReceipt.ts
@@ -4787,6 +4697,63 @@ var RpcProvider = class {
   async getBlockWithTxs(blockIdentifier) {
     return this.channel.getBlockWithTxs(blockIdentifier);
   }
+  /**
+   * Pause the execution of the script until a specified block is created.
+   * @param {BlockIdentifier} blockIdentifier bloc number (BigNumberisk) or 'pending' or 'latest'.
+   * Use of 'latest" or of a block already created will generate no pause.
+   * @param {number} [retryInterval] number of milliseconds between 2 requests to the node
+   * @example
+   * ```typescript
+   * await myProvider.waitForBlock();
+   * // wait the creation of the pending block
+   * ```
+   */
+  async waitForBlock(blockIdentifier = "pending", retryInterval = 5e3) {
+    if (blockIdentifier === "latest" /* latest */)
+      return;
+    const currentBlock = await this.getBlockNumber();
+    const targetBlock = blockIdentifier === "pending" /* pending */ ? currentBlock + 1 : Number(toHex(blockIdentifier));
+    if (targetBlock <= currentBlock)
+      return;
+    const { retries } = this.channel;
+    let retriesCount = retries;
+    let isTargetBlock = false;
+    while (!isTargetBlock) {
+      const currBlock = await this.getBlockNumber();
+      if (currBlock === targetBlock) {
+        isTargetBlock = true;
+      } else {
+        await wait(retryInterval);
+      }
+      retriesCount -= 1;
+      if (retriesCount <= 0) {
+        throw new Error(`waitForBlock() timed-out after ${retries} tries.`);
+      }
+    }
+  }
+  async getL1GasPrice(blockIdentifier) {
+    return this.channel.getBlockWithTxHashes(blockIdentifier).then(this.responseParser.parseL1GasPriceResponse);
+  }
+  async getL1MessageHash(l2TxHash) {
+    const transaction = await this.channel.getTransactionByHash(l2TxHash);
+    assert(transaction.type === "L1_HANDLER", "This L2 transaction is not a L1 message.");
+    const { calldata, contract_address, entry_point_selector, nonce } = transaction;
+    const params = [
+      calldata[0],
+      contract_address,
+      nonce,
+      entry_point_selector,
+      calldata.length - 1,
+      ...calldata.slice(1)
+    ];
+    const myEncode = addHexPrefix(
+      params.reduce(
+        (res, par) => res + removeHexPrefix(toHex(par)).padStart(64, "0"),
+        ""
+      )
+    );
+    return addHexPrefix((0, import_utils2.bytesToHex)((0, import_sha3.keccak_256)(hexToBytes(myEncode))));
+  }
   async getBlockWithReceipts(blockIdentifier) {
     if (this.channel instanceof rpc_0_6_exports.RpcChannel)
       throw new LibraryError("Unsupported method for RPC version");
@@ -4838,7 +4805,7 @@ var RpcProvider = class {
   }
   /**
    * @param invocations AccountInvocations
-   * @param simulateTransactionOptions blockIdentifier and flags to skip validation and fee charge<br/>
+   * @param options blockIdentifier and flags to skip validation and fee charge<br/>
    * - blockIdentifier<br/>
    * - skipValidate (default false)<br/>
    * - skipFeeCharge (default true)<br/>
@@ -5079,7 +5046,6 @@ function useEncoded(decoded) {
 }
 var StarknetIdContract = /* @__PURE__ */ ((StarknetIdContract2) => {
   StarknetIdContract2["MAINNET"] = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678";
-  StarknetIdContract2["TESTNET"] = "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce";
   StarknetIdContract2["TESTNET_SEPOLIA"] = "0x0707f09bc576bd7cfee59694846291047e965f4184fe13dac62c56759b3b6fa7";
   return StarknetIdContract2;
 })(StarknetIdContract || {});
@@ -5087,8 +5053,6 @@ function getStarknetIdContract(chainId) {
   switch (chainId) {
     case "0x534e5f4d41494e" /* SN_MAIN */:
       return "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678" /* MAINNET */;
-    case "0x534e5f474f45524c49" /* SN_GOERLI */:
-      return "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce" /* TESTNET */;
     case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
       return "0x0707f09bc576bd7cfee59694846291047e965f4184fe13dac62c56759b3b6fa7" /* TESTNET_SEPOLIA */;
     default:
@@ -5097,7 +5061,6 @@ function getStarknetIdContract(chainId) {
 }
 var StarknetIdIdentityContract = /* @__PURE__ */ ((StarknetIdIdentityContract2) => {
   StarknetIdIdentityContract2["MAINNET"] = "0x05dbdedc203e92749e2e746e2d40a768d966bd243df04a6b712e222bc040a9af";
-  StarknetIdIdentityContract2["TESTNET"] = "0x783a9097b26eae0586373b2ce0ed3529ddc44069d1e0fbc4f66d42b69d6850d";
   StarknetIdIdentityContract2["TESTNET_SEPOLIA"] = "0x070DF8B4F5cb2879f8592849fA8f3134da39d25326B8558cc9C8FE8D47EA3A90";
   return StarknetIdIdentityContract2;
 })(StarknetIdIdentityContract || {});
@@ -5105,8 +5068,6 @@ function getStarknetIdIdentityContract(chainId) {
   switch (chainId) {
     case "0x534e5f4d41494e" /* SN_MAIN */:
       return "0x05dbdedc203e92749e2e746e2d40a768d966bd243df04a6b712e222bc040a9af" /* MAINNET */;
-    case "0x534e5f474f45524c49" /* SN_GOERLI */:
-      return "0x783a9097b26eae0586373b2ce0ed3529ddc44069d1e0fbc4f66d42b69d6850d" /* TESTNET */;
     case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
       return "0x070DF8B4F5cb2879f8592849fA8f3134da39d25326B8558cc9C8FE8D47EA3A90" /* TESTNET_SEPOLIA */;
     default:
@@ -5118,8 +5079,6 @@ function getStarknetIdMulticallContract(chainId) {
   switch (chainId) {
     case "0x534e5f4d41494e" /* SN_MAIN */:
       return StarknetIdMulticallContract;
-    case "0x534e5f474f45524c49" /* SN_GOERLI */:
-      return StarknetIdMulticallContract;
     case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
       return StarknetIdMulticallContract;
     default:
@@ -5128,7 +5087,6 @@ function getStarknetIdMulticallContract(chainId) {
 }
 var StarknetIdVerifierContract = /* @__PURE__ */ ((StarknetIdVerifierContract2) => {
   StarknetIdVerifierContract2["MAINNET"] = "0x07d14dfd8ee95b41fce179170d88ba1f0d5a512e13aeb232f19cfeec0a88f8bf";
-  StarknetIdVerifierContract2["TESTNET"] = "0x057c942544063c3aea6ea6c37009cc9d1beacd750cb6801549a129c7265f0f11";
   StarknetIdVerifierContract2["TESTNET_SEPOLIA"] = "0x0182EcE8173C216A395f4828e1523541b7e3600bf190CB252E1a1A0cE219d184";
   return StarknetIdVerifierContract2;
 })(StarknetIdVerifierContract || {});
@@ -5136,8 +5094,6 @@ function getStarknetIdVerifierContract(chainId) {
   switch (chainId) {
     case "0x534e5f4d41494e" /* SN_MAIN */:
       return "0x07d14dfd8ee95b41fce179170d88ba1f0d5a512e13aeb232f19cfeec0a88f8bf" /* MAINNET */;
-    case "0x534e5f474f45524c49" /* SN_GOERLI */:
-      return "0x057c942544063c3aea6ea6c37009cc9d1beacd750cb6801549a129c7265f0f11" /* TESTNET */;
     case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
       return "0x0182EcE8173C216A395f4828e1523541b7e3600bf190CB252E1a1A0cE219d184" /* TESTNET_SEPOLIA */;
     default:
@@ -5146,7 +5102,6 @@ function getStarknetIdVerifierContract(chainId) {
 }
 var StarknetIdPfpContract = /* @__PURE__ */ ((StarknetIdPfpContract2) => {
   StarknetIdPfpContract2["MAINNET"] = "0x070aaa20ec4a46da57c932d9fd89ca5e6bb9ca3188d3df361a32306aff7d59c7";
-  StarknetIdPfpContract2["TESTNET"] = "0x03cac3228b434259734ee0e4ff445f642206ea11adace7e4f45edd2596748698";
   StarknetIdPfpContract2["TESTNET_SEPOLIA"] = "0x058061bb6bdc501eE215172c9f87d557C1E0f466dC498cA81b18f998Bf1362b2";
   return StarknetIdPfpContract2;
 })(StarknetIdPfpContract || {});
@@ -5154,8 +5109,6 @@ function getStarknetIdPfpContract(chainId) {
   switch (chainId) {
     case "0x534e5f4d41494e" /* SN_MAIN */:
       return "0x070aaa20ec4a46da57c932d9fd89ca5e6bb9ca3188d3df361a32306aff7d59c7" /* MAINNET */;
-    case "0x534e5f474f45524c49" /* SN_GOERLI */:
-      return "0x03cac3228b434259734ee0e4ff445f642206ea11adace7e4f45edd2596748698" /* TESTNET */;
     case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
       return "0x058061bb6bdc501eE215172c9f87d557C1E0f466dC498cA81b18f998Bf1362b2" /* TESTNET_SEPOLIA */;
     default:
@@ -5166,7 +5119,6 @@ function getStarknetIdPfpContract(chainId) {
 }
 var StarknetIdPopContract = /* @__PURE__ */ ((StarknetIdPopContract2) => {
   StarknetIdPopContract2["MAINNET"] = "0x0293eb2ba9862f762bd3036586d5755a782bd22e6f5028320f1d0405fd47bff4";
-  StarknetIdPopContract2["TESTNET"] = "0x03528caf090179e337931ee669a5b0214041e1bae30d460ff07d2cea2c7a9106";
   StarknetIdPopContract2["TESTNET_SEPOLIA"] = "0x0023FE3b845ed5665a9eb3792bbB17347B490EE4090f855C1298d03BB5F49B49";
   return StarknetIdPopContract2;
 })(StarknetIdPopContract || {});
@@ -5174,8 +5126,6 @@ function getStarknetIdPopContract(chainId) {
   switch (chainId) {
     case "0x534e5f4d41494e" /* SN_MAIN */:
       return "0x0293eb2ba9862f762bd3036586d5755a782bd22e6f5028320f1d0405fd47bff4" /* MAINNET */;
-    case "0x534e5f474f45524c49" /* SN_GOERLI */:
-      return "0x03528caf090179e337931ee669a5b0214041e1bae30d460ff07d2cea2c7a9106" /* TESTNET */;
     case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
       return "0x0023FE3b845ed5665a9eb3792bbB17347B490EE4090f855C1298d03BB5F49B49" /* TESTNET_SEPOLIA */;
     default:
@@ -5240,13 +5190,7 @@ var StarknetId = class _StarknetId {
     const chainId = await provider.getChainId();
     const contract = StarknetIdContract2 ?? getStarknetIdContract(chainId);
     try {
-      const hexDomain = await provider.callContract({
-        contractAddress: contract,
-        entrypoint: "address_to_domain",
-        calldata: CallData.compile({
-          address
-        })
-      });
+      const hexDomain = await this.executeStarkName(provider, address, contract);
       const decimalDomain = hexDomain.map((element) => BigInt(element)).slice(1);
       const stringDomain = useDecoded(decimalDomain);
       if (!stringDomain) {
@@ -5260,6 +5204,26 @@ var StarknetId = class _StarknetId {
       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);
@@ -5284,100 +5248,111 @@ var StarknetId = class _StarknetId {
     const popContract = StarknetIdPopContract2 ?? getStarknetIdPopContract(chainId);
     const multicallAddress = StarknetIdMulticallContract2 ?? getStarknetIdMulticallContract(chainId);
     try {
-      const data = await provider.callContract({
-        contractAddress: multicallAddress,
-        entrypoint: "aggregate",
-        calldata: CallData.compile({
-          calls: [
-            {
-              execution: execution({}),
-              to: dynamicFelt(contract),
-              selector: dynamicFelt(getSelectorFromName("address_to_domain")),
-              calldata: [dynamicCallData(address)]
-            },
-            {
-              execution: execution({}),
-              to: dynamicFelt(contract),
-              selector: dynamicFelt(getSelectorFromName("domain_to_id")),
-              calldata: [dynamicCallData(void 0, void 0, [0, 0])]
-            },
-            {
-              execution: execution({}),
-              to: dynamicFelt(identityContract),
-              selector: dynamicFelt(getSelectorFromName("get_verifier_data")),
-              calldata: [
-                dynamicCallData(void 0, [1, 0]),
-                dynamicCallData(encodeShortString("twitter")),
-                dynamicCallData(verifierContract),
-                dynamicCallData("0")
-              ]
-            },
-            {
-              execution: execution({}),
-              to: dynamicFelt(identityContract),
-              selector: dynamicFelt(getSelectorFromName("get_verifier_data")),
-              calldata: [
-                dynamicCallData(void 0, [1, 0]),
-                dynamicCallData(encodeShortString("github")),
-                dynamicCallData(verifierContract),
-                dynamicCallData("0")
-              ]
-            },
-            {
-              execution: execution({}),
-              to: dynamicFelt(identityContract),
-              selector: dynamicFelt(getSelectorFromName("get_verifier_data")),
-              calldata: [
-                dynamicCallData(void 0, [1, 0]),
-                dynamicCallData(encodeShortString("discord")),
-                dynamicCallData(verifierContract),
-                dynamicCallData("0")
-              ]
-            },
-            {
-              execution: execution({}),
-              to: dynamicFelt(identityContract),
-              selector: dynamicFelt(getSelectorFromName("get_verifier_data")),
-              calldata: [
-                dynamicCallData(void 0, [1, 0]),
-                dynamicCallData(encodeShortString("proof_of_personhood")),
-                dynamicCallData(popContract),
-                dynamicCallData("0")
-              ]
-            },
-            // PFP
-            {
-              execution: execution({}),
-              to: dynamicFelt(identityContract),
-              selector: dynamicFelt(getSelectorFromName("get_verifier_data")),
-              calldata: [
-                dynamicCallData(void 0, [1, 0]),
-                dynamicCallData(encodeShortString("nft_pp_contract")),
-                dynamicCallData(pfpContract),
-                dynamicCallData("0")
-              ]
-            },
-            {
-              execution: execution({}),
-              to: dynamicFelt(identityContract),
-              selector: dynamicFelt(getSelectorFromName("get_extended_verifier_data")),
-              calldata: [
-                dynamicCallData(void 0, [1, 0]),
-                dynamicCallData(encodeShortString("nft_pp_id")),
-                dynamicCallData("2"),
-                dynamicCallData(pfpContract),
-                dynamicCallData("0")
-              ]
-            },
-            {
-              execution: execution(void 0, void 0, [6, 0, 0]),
-              to: dynamicFelt(void 0, [6, 0]),
-              selector: dynamicFelt(getSelectorFromName("tokenURI")),
-              calldata: [dynamicCallData(void 0, [7, 1]), dynamicCallData(void 0, [7, 2])]
-            }
-          ]
-        })
+      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: dynamicFelt(contract),
+          selector: dynamicFelt(getSelectorFromName("domain_to_id")),
+          calldata: [dynamicCallData(void 0, void 0, [0, 0])]
+        },
+        {
+          execution: execution({}),
+          to: dynamicFelt(identityContract),
+          selector: dynamicFelt(getSelectorFromName("get_verifier_data")),
+          calldata: [
+            dynamicCallData(void 0, [1, 0]),
+            dynamicCallData(encodeShortString("twitter")),
+            dynamicCallData(verifierContract),
+            dynamicCallData("0")
+          ]
+        },
+        {
+          execution: execution({}),
+          to: dynamicFelt(identityContract),
+          selector: dynamicFelt(getSelectorFromName("get_verifier_data")),
+          calldata: [
+            dynamicCallData(void 0, [1, 0]),
+            dynamicCallData(encodeShortString("github")),
+            dynamicCallData(verifierContract),
+            dynamicCallData("0")
+          ]
+        },
+        {
+          execution: execution({}),
+          to: dynamicFelt(identityContract),
+          selector: dynamicFelt(getSelectorFromName("get_verifier_data")),
+          calldata: [
+            dynamicCallData(void 0, [1, 0]),
+            dynamicCallData(encodeShortString("discord")),
+            dynamicCallData(verifierContract),
+            dynamicCallData("0")
+          ]
+        },
+        {
+          execution: execution({}),
+          to: dynamicFelt(identityContract),
+          selector: dynamicFelt(getSelectorFromName("get_verifier_data")),
+          calldata: [
+            dynamicCallData(void 0, [1, 0]),
+            dynamicCallData(encodeShortString("proof_of_personhood")),
+            dynamicCallData(popContract),
+            dynamicCallData("0")
+          ]
+        },
+        // PFP
+        {
+          execution: execution({}),
+          to: dynamicFelt(identityContract),
+          selector: dynamicFelt(getSelectorFromName("get_verifier_data")),
+          calldata: [
+            dynamicCallData(void 0, [1, 0]),
+            dynamicCallData(encodeShortString("nft_pp_contract")),
+            dynamicCallData(pfpContract),
+            dynamicCallData("0")
+          ]
+        },
+        {
+          execution: execution({}),
+          to: dynamicFelt(identityContract),
+          selector: dynamicFelt(getSelectorFromName("get_extended_verifier_data")),
+          calldata: [
+            dynamicCallData(void 0, [1, 0]),
+            dynamicCallData(encodeShortString("nft_pp_id")),
+            dynamicCallData("2"),
+            dynamicCallData(pfpContract),
+            dynamicCallData("0")
+          ]
+        },
+        {
+          execution: execution(void 0, void 0, [6, 0, 0]),
+          to: dynamicFelt(void 0, [6, 0]),
+          selector: dynamicFelt(getSelectorFromName("tokenURI")),
+          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
+      );
       if (Array.isArray(data)) {
         const size = parseInt(data[0], 16);
         const finalArray = [];
@@ -5417,6 +5392,25 @@ var StarknetId = class _StarknetId {
       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
@@ -5437,7 +5431,7 @@ var SignerInterface = class {
 // src/utils/typedData.ts
 var typedData_exports = {};
 __export(typedData_exports, {
-  TypedDataRevision: () => import_starknet_types.TypedDataRevision,
+  TypedDataRevision: () => import_starknet_types_07.TypedDataRevision,
   encodeData: () => encodeData,
   encodeType: () => encodeType,
   encodeValue: () => encodeValue,
@@ -5541,14 +5535,14 @@ var presetTypes = {
   )
 };
 var revisionConfiguration = {
-  [import_starknet_types.TypedDataRevision.Active]: {
+  [import_starknet_types_07.TypedDataRevision.Active]: {
     domain: "StarknetDomain",
     hashMethod: computePoseidonHashOnElements,
     hashMerkleMethod: computePoseidonHash,
     escapeTypeString: (s) => `"${s}"`,
     presetTypes
   },
-  [import_starknet_types.TypedDataRevision.Legacy]: {
+  [import_starknet_types_07.TypedDataRevision.Legacy]: {
     domain: "StarkNetDomain",
     hashMethod: computePedersenHashOnElements,
     hashMerkleMethod: computePedersenHash,
@@ -5561,10 +5555,10 @@ function assertRange(data, type, { min, max }) {
   assert(value >= min && value <= max, `${value} (${type}) is out of bounds [${min}, ${max}]`);
 }
 function identifyRevision({ types, domain }) {
-  if (revisionConfiguration[import_starknet_types.TypedDataRevision.Active].domain in types && domain.revision === import_starknet_types.TypedDataRevision.Active)
-    return import_starknet_types.TypedDataRevision.Active;
-  if (revisionConfiguration[import_starknet_types.TypedDataRevision.Legacy].domain in types && (domain.revision ?? import_starknet_types.TypedDataRevision.Legacy) === import_starknet_types.TypedDataRevision.Legacy)
-    return import_starknet_types.TypedDataRevision.Legacy;
+  if (revisionConfiguration[import_starknet_types_07.TypedDataRevision.Active].domain in types && domain.revision === import_starknet_types_07.TypedDataRevision.Active)
+    return import_starknet_types_07.TypedDataRevision.Active;
+  if (revisionConfiguration[import_starknet_types_07.TypedDataRevision.Legacy].domain in types && (domain.revision ?? import_starknet_types_07.TypedDataRevision.Legacy) === import_starknet_types_07.TypedDataRevision.Legacy)
+    return import_starknet_types_07.TypedDataRevision.Legacy;
   return void 0;
 }
 function getHex(value) {
@@ -5589,10 +5583,10 @@ function prepareSelector(selector) {
 function isMerkleTreeType(type) {
   return type.type === "merkletree";
 }
-function getDependencies(types, type, dependencies = [], contains = "", revision = import_starknet_types.TypedDataRevision.Legacy) {
+function getDependencies(types, type, dependencies = [], contains = "", revision = import_starknet_types_07.TypedDataRevision.Legacy) {
   if (type[type.length - 1] === "*") {
     type = type.slice(0, -1);
-  } else if (revision === import_starknet_types.TypedDataRevision.Active) {
+  } else if (revision === import_starknet_types_07.TypedDataRevision.Active) {
     if (type === "enum") {
       type = contains;
     } else if (type.match(/^\(.*\)$/)) {
@@ -5630,8 +5624,8 @@ function getMerkleTreeType(types, ctx) {
   }
   return "raw";
 }
-function encodeType(types, type, revision = import_starknet_types.TypedDataRevision.Legacy) {
-  const allTypes = revision === import_starknet_types.TypedDataRevision.Active ? { ...types, ...revisionConfiguration[revision].presetTypes } : types;
+function encodeType(types, type, revision = import_starknet_types_07.TypedDataRevision.Legacy) {
+  const allTypes = revision === import_starknet_types_07.TypedDataRevision.Active ? { ...types, ...revisionConfiguration[revision].presetTypes } : types;
   const [primary, ...dependencies] = getDependencies(
     allTypes,
     type,
@@ -5643,17 +5637,17 @@ function encodeType(types, type, revision = import_starknet_types.TypedDataRevis
   const esc = revisionConfiguration[revision].escapeTypeString;
   return newTypes.map((dependency) => {
     const dependencyElements = allTypes[dependency].map((t) => {
-      const targetType = t.type === "enum" && revision === import_starknet_types.TypedDataRevision.Active ? t.contains : t.type;
+      const targetType = t.type === "enum" && revision === import_starknet_types_07.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 = import_starknet_types.TypedDataRevision.Legacy) {
+function getTypeHash(types, type, revision = import_starknet_types_07.TypedDataRevision.Legacy) {
   return getSelectorFromName(encodeType(types, type, revision));
 }
-function encodeValue(types, type, data, ctx = {}, revision = import_starknet_types.TypedDataRevision.Legacy) {
+function encodeValue(types, type, data, ctx = {}, revision = import_starknet_types_07.TypedDataRevision.Legacy) {
   if (types[type]) {
     return [type, getStructHash(types, type, data, revision)];
   }
@@ -5676,7 +5670,7 @@ function encodeValue(types, type, data, ctx = {}, revision = import_starknet_typ
   }
   switch (type) {
     case "enum": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         const [variantKey, variantData] = Object.entries(data)[0];
         const parentType = types[ctx.parent][0];
         const enumType = types[parentType.contains];
@@ -5710,7 +5704,7 @@ function encodeValue(types, type, data, ctx = {}, revision = import_starknet_typ
       return ["felt", prepareSelector(data)];
     }
     case "string": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         const byteArray = byteArrayFromString(data);
         const elements = [
           byteArray.data.length,
@@ -5723,7 +5717,7 @@ function encodeValue(types, type, data, ctx = {}, revision = import_starknet_typ
       return [type, getHex(data)];
     }
     case "i128": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         const value = BigInt(data);
         assertRange(value, type, RANGE_I128);
         return [type, getHex(value < 0n ? PRIME + value : value)];
@@ -5732,40 +5726,40 @@ function encodeValue(types, type, data, ctx = {}, revision = import_starknet_typ
     }
     case "timestamp":
     case "u128": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         assertRange(data, type, RANGE_U128);
       }
       return [type, getHex(data)];
     }
     case "felt":
     case "shortstring": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         assertRange(getHex(data), type, RANGE_FELT);
       }
       return [type, getHex(data)];
     }
     case "ClassHash":
     case "ContractAddress": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         assertRange(data, type, RANGE_FELT);
       }
       return [type, getHex(data)];
     }
     case "bool": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         assert(typeof data === "boolean", `Type mismatch for ${type} ${data}`);
       }
       return [type, getHex(data)];
     }
     default: {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         throw new Error(`Unsupported type: ${type}`);
       }
       return [type, getHex(data)];
     }
   }
 }
-function encodeData(types, type, data, revision = import_starknet_types.TypedDataRevision.Legacy) {
+function encodeData(types, type, data, revision = import_starknet_types_07.TypedDataRevision.Legacy) {
   const targetType = types[type] ?? revisionConfiguration[revision].presetTypes[type];
   const [returnTypes, values] = targetType.reduce(
     ([ts, vs], field) => {
@@ -5784,7 +5778,7 @@ function encodeData(types, type, data, revision = import_starknet_types.TypedDat
   );
   return [returnTypes, values];
 }
-function getStructHash(types, type, data, revision = import_starknet_types.TypedDataRevision.Legacy) {
+function getStructHash(types, type, data, revision = import_starknet_types_07.TypedDataRevision.Legacy) {
   return revisionConfiguration[revision].hashMethod(encodeData(types, type, data, revision)[1]);
 }
 function getMessageHash(typedData, account) {
@@ -5818,7 +5812,7 @@ var Signer = class {
   async signTransaction(transactions, details) {
     const compiledCalldata = getExecuteCalldata(transactions, details.cairoVersion);
     let msgHash;
-    if (Object.values(ETransactionVersion22).includes(details.version)) {
+    if (Object.values(api_exports.ETransactionVersion2).includes(details.version)) {
       const det = details;
       msgHash = calculateInvokeTransactionHash2({
         ...det,
@@ -5826,7 +5820,7 @@ var Signer = class {
         compiledCalldata,
         version: det.version
       });
-    } else if (Object.values(ETransactionVersion32).includes(details.version)) {
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
       const det = details;
       msgHash = calculateInvokeTransactionHash2({
         ...det,
@@ -5844,7 +5838,7 @@ var Signer = class {
   async signDeployAccountTransaction(details) {
     const compiledConstructorCalldata = CallData.compile(details.constructorCalldata);
     let msgHash;
-    if (Object.values(ETransactionVersion22).includes(details.version)) {
+    if (Object.values(api_exports.ETransactionVersion2).includes(details.version)) {
       const det = details;
       msgHash = calculateDeployAccountTransactionHash3({
         ...det,
@@ -5852,7 +5846,7 @@ var Signer = class {
         constructorCalldata: compiledConstructorCalldata,
         version: det.version
       });
-    } else if (Object.values(ETransactionVersion32).includes(details.version)) {
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
       const det = details;
       msgHash = calculateDeployAccountTransactionHash3({
         ...det,
@@ -5869,13 +5863,13 @@ var Signer = class {
   }
   async signDeclareTransaction(details) {
     let msgHash;
-    if (Object.values(ETransactionVersion22).includes(details.version)) {
+    if (Object.values(api_exports.ETransactionVersion2).includes(details.version)) {
       const det = details;
       msgHash = calculateDeclareTransactionHash3({
         ...det,
         version: det.version
       });
-    } else if (Object.values(ETransactionVersion32).includes(details.version)) {
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
       const det = details;
       msgHash = calculateDeclareTransactionHash3({
         ...det,
@@ -5942,7 +5936,7 @@ var EthSigner = class {
   async signTransaction(transactions, details) {
     const compiledCalldata = getExecuteCalldata(transactions, details.cairoVersion);
     let msgHash;
-    if (Object.values(ETransactionVersion22).includes(details.version)) {
+    if (Object.values(api_exports.ETransactionVersion2).includes(details.version)) {
       const det = details;
       msgHash = calculateInvokeTransactionHash2({
         ...det,
@@ -5950,7 +5944,7 @@ var EthSigner = class {
         compiledCalldata,
         version: det.version
       });
-    } else if (Object.values(ETransactionVersion32).includes(details.version)) {
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
       const det = details;
       msgHash = calculateInvokeTransactionHash2({
         ...det,
@@ -5972,7 +5966,7 @@ var EthSigner = class {
   async signDeployAccountTransaction(details) {
     const compiledConstructorCalldata = CallData.compile(details.constructorCalldata);
     let msgHash;
-    if (Object.values(ETransactionVersion22).includes(details.version)) {
+    if (Object.values(api_exports.ETransactionVersion2).includes(details.version)) {
       const det = details;
       msgHash = calculateDeployAccountTransactionHash3({
         ...det,
@@ -5980,7 +5974,7 @@ var EthSigner = class {
         constructorCalldata: compiledConstructorCalldata,
         version: det.version
       });
-    } else if (Object.values(ETransactionVersion32).includes(details.version)) {
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
       const det = details;
       msgHash = calculateDeployAccountTransactionHash3({
         ...det,
@@ -6001,13 +5995,13 @@ var EthSigner = class {
   }
   async signDeclareTransaction(details) {
     let msgHash;
-    if (Object.values(ETransactionVersion22).includes(details.version)) {
+    if (Object.values(api_exports.ETransactionVersion2).includes(details.version)) {
       const det = details;
       msgHash = calculateDeclareTransactionHash3({
         ...det,
         version: det.version
       });
-    } else if (Object.values(ETransactionVersion32).includes(details.version)) {
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
       const det = details;
       msgHash = calculateDeclareTransactionHash3({
         ...det,
@@ -6071,7 +6065,7 @@ var Account = class extends RpcProvider2 {
   address;
   cairoVersion;
   transactionVersion;
-  constructor(providerOrOptions, address, pkOrSigner, cairoVersion, transactionVersion = "0x2" /* V2 */) {
+  constructor(providerOrOptions, address, pkOrSigner, cairoVersion, transactionVersion = api_exports.ETransactionVersion.V2) {
     super(providerOrOptions);
     this.address = address.toLowerCase();
     this.signer = isString(pkOrSigner) || pkOrSigner instanceof Uint8Array ? new Signer(pkOrSigner) : pkOrSigner;
@@ -6082,11 +6076,11 @@ var Account = class extends RpcProvider2 {
   }
   // provided version or contract based preferred transactionVersion
   getPreferredVersion(type12, type3) {
-    if (this.transactionVersion === "0x3" /* V3 */)
+    if (this.transactionVersion === api_exports.ETransactionVersion.V3)
       return type3;
-    if (this.transactionVersion === "0x2" /* V2 */)
+    if (this.transactionVersion === api_exports.ETransactionVersion.V2)
       return type12;
-    return "0x3" /* V3 */;
+    return api_exports.ETransactionVersion.V3;
   }
   async getNonce(blockIdentifier) {
     return super.getNonceForAddress(this.address, blockIdentifier);
@@ -6099,7 +6093,7 @@ var Account = class extends RpcProvider2 {
     }
   }
   /**
-   * Retrieves the Cairo version from the network and sets `cairoVersion` if not already set in the constructor
+   * Retrieves the Cairo version from the network and sets `cairoVersion` if not already set in the constructor.
    * @param classHash if provided detects Cairo version from classHash, otherwise from the account address
    */
   async getCairoVersion(classHash) {
@@ -6122,7 +6116,7 @@ var Account = class extends RpcProvider2 {
     const transactions = Array.isArray(calls) ? calls : [calls];
     const nonce = toBigInt(providedNonce ?? await this.getNonce());
     const version = toTransactionVersion(
-      this.getPreferredVersion("0x100000000000000000000000000000001" /* F1 */, "0x100000000000000000000000000000003" /* F3 */),
+      this.getPreferredVersion(api_exports.ETransactionVersion.F1, api_exports.ETransactionVersion.F3),
       toFeeVersion(providedVersion)
     );
     const chainId = await this.getChainId();
@@ -6153,7 +6147,7 @@ var Account = class extends RpcProvider2 {
     } = details;
     const nonce = toBigInt(providedNonce ?? await this.getNonce());
     const version = toTransactionVersion(
-      !isSierra(payload.contract) ? "0x100000000000000000000000000000001" /* F1 */ : this.getPreferredVersion("0x100000000000000000000000000000002" /* F2 */, "0x100000000000000000000000000000003" /* F3 */),
+      !isSierra(payload.contract) ? api_exports.ETransactionVersion.F1 : this.getPreferredVersion(api_exports.ETransactionVersion.F2, api_exports.ETransactionVersion.F3),
       toFeeVersion(providedVersion)
     );
     const chainId = await this.getChainId();
@@ -6183,7 +6177,7 @@ var Account = class extends RpcProvider2 {
   }, details = {}) {
     const { blockIdentifier, version: providedVersion, skipValidate = true } = details;
     const version = toTransactionVersion(
-      this.getPreferredVersion("0x100000000000000000000000000000001" /* F1 */, "0x100000000000000000000000000000003" /* F3 */),
+      this.getPreferredVersion(api_exports.ETransactionVersion.F1, api_exports.ETransactionVersion.F3),
       toFeeVersion(providedVersion)
     );
     const nonce = ZERO;
@@ -6219,10 +6213,10 @@ var Account = class extends RpcProvider2 {
     const accountInvocations = await this.accountInvocationsFactory(invocations, {
       ...v3Details(details),
       versions: [
-        "0x100000000000000000000000000000001" /* F1 */,
+        api_exports.ETransactionVersion.F1,
         // non-sierra
         toTransactionVersion(
-          this.getPreferredVersion("0x100000000000000000000000000000002" /* F2 */, "0x100000000000000000000000000000003" /* F3 */),
+          this.getPreferredVersion(api_exports.ETransactionVersion.F2, api_exports.ETransactionVersion.F3),
           version
         )
         // sierra
@@ -6241,10 +6235,10 @@ var Account = class extends RpcProvider2 {
     const accountInvocations = await this.accountInvocationsFactory(invocations, {
       ...v3Details(details),
       versions: [
-        "0x1" /* V1 */,
+        api_exports.ETransactionVersion.V1,
         // non-sierra
         toTransactionVersion(
-          this.getPreferredVersion("0x2" /* V2 */, "0x3" /* V3 */),
+          this.getPreferredVersion(api_exports.ETransactionVersion.V2, api_exports.ETransactionVersion.V3),
           version
         )
       ],
@@ -6263,7 +6257,7 @@ var Account = class extends RpcProvider2 {
     const calls = Array.isArray(transactions) ? transactions : [transactions];
     const nonce = toBigInt(details.nonce ?? await this.getNonce());
     const version = toTransactionVersion(
-      this.getPreferredVersion("0x1" /* V1 */, "0x3" /* V3 */),
+      this.getPreferredVersion(api_exports.ETransactionVersion.V1, api_exports.ETransactionVersion.V3),
       // TODO: does this depend on cairo version ?
       details.version
     );
@@ -6321,7 +6315,7 @@ var Account = class extends RpcProvider2 {
     const declareContractPayload = extractContractHashes(payload);
     const { nonce, version: providedVersion } = details;
     const version = toTransactionVersion(
-      !isSierra(payload.contract) ? "0x1" /* V1 */ : this.getPreferredVersion("0x2" /* V2 */, "0x3" /* V3 */),
+      !isSierra(payload.contract) ? api_exports.ETransactionVersion.V1 : this.getPreferredVersion(api_exports.ETransactionVersion.V2, api_exports.ETransactionVersion.V3),
       providedVersion
     );
     const estimate = await this.getUniversalSuggestedFee(
@@ -6385,7 +6379,7 @@ var Account = class extends RpcProvider2 {
     contractAddress: providedContractAddress
   }, details = {}) {
     const version = toTransactionVersion(
-      this.getPreferredVersion("0x1" /* V1 */, "0x3" /* V3 */),
+      this.getPreferredVersion(api_exports.ETransactionVersion.V1, api_exports.ETransactionVersion.V3),
       details.version
     );
     const nonce = ZERO;
@@ -6434,32 +6428,64 @@ var Account = class extends RpcProvider2 {
   async hashMessage(typedData) {
     return getMessageHash(typedData, this.address);
   }
-  async verifyMessageHash(hash, signature) {
-    try {
-      const resp = await this.callContract({
-        contractAddress: this.address,
-        entrypoint: "isValidSignature",
-        calldata: CallData.compile({
-          hash: toBigInt(hash).toString(),
-          signature: formatSignature(signature)
-        })
-      });
-      if (BigInt(resp[0]) === 0n) {
-        return false;
-      }
-      return true;
-    } catch (err) {
-      if (["argent/invalid-signature", "is invalid, with respect to the public key"].some(
-        (errMessage) => err.message.includes(errMessage)
-      )) {
-        return false;
+  async verifyMessageHash(hash, signature, signatureVerificationFunctionName, signatureVerificationResponse) {
+    const knownSigVerificationFName = signatureVerificationFunctionName ? [signatureVerificationFunctionName] : ["isValidSignature", "is_valid_signature"];
+    const knownSignatureResponse = signatureVerificationResponse || {
+      okResponse: [
+        // any non-nok response is true
+      ],
+      nokResponse: [
+        "0x0",
+        // Devnet
+        "0x00"
+        // OpenZeppelin 0.7.0 to 0.9.0 invalid signature
+      ],
+      error: [
+        "argent/invalid-signature",
+        // ArgentX 0.3.0 to 0.3.1
+        "is invalid, with respect to the public key",
+        // OpenZeppelin until 0.6.1, Braavos 0.0.11
+        "INVALID_SIG"
+        // Braavos 1.0.0
+      ]
+    };
+    let error;
+    for (const SigVerificationFName of knownSigVerificationFName) {
+      try {
+        const resp = await this.callContract({
+          contractAddress: this.address,
+          entrypoint: SigVerificationFName,
+          calldata: CallData.compile({
+            hash: toBigInt(hash).toString(),
+            signature: formatSignature(signature)
+          })
+        });
+        if (knownSignatureResponse.nokResponse.includes(resp[0].toString())) {
+          return false;
+        }
+        if (knownSignatureResponse.okResponse.length === 0 || knownSignatureResponse.okResponse.includes(resp[0].toString())) {
+          return true;
+        }
+        throw Error("signatureVerificationResponse Error: response is not part of known responses");
+      } catch (err) {
+        if (knownSignatureResponse.error.some(
+          (errMessage) => err.message.includes(errMessage)
+        )) {
+          return false;
+        }
+        error = err;
       }
-      throw Error(`Signature verification request is rejected by the network: ${err}`);
     }
+    throw Error(`Signature verification Error: ${error}`);
   }
-  async verifyMessage(typedData, signature) {
+  async verifyMessage(typedData, signature, signatureVerificationFunctionName, signatureVerificationResponse) {
     const hash = await this.hashMessage(typedData);
-    return this.verifyMessageHash(hash, signature);
+    return this.verifyMessageHash(
+      hash,
+      signature,
+      signatureVerificationFunctionName,
+      signatureVerificationResponse
+    );
   }
   /*
    * Support methods
@@ -6467,7 +6493,7 @@ var Account = class extends RpcProvider2 {
   async getUniversalSuggestedFee(version, { type, payload }, details) {
     let maxFee = 0;
     let resourceBounds = estimateFeeToBounds(ZERO);
-    if (version === "0x3" /* V3 */) {
+    if (version === api_exports.ETransactionVersion.V3) {
       resourceBounds = details.resourceBounds ?? (await this.getSuggestedFee({ type, payload }, details)).resourceBounds;
     } else {
       maxFee = details.maxFee ?? (await this.getSuggestedFee({ type, payload }, details)).suggestedMaxFee;
@@ -6520,7 +6546,7 @@ var Account = class extends RpcProvider2 {
   async buildDeclarePayload(payload, details) {
     const { classHash, contract, compiledClassHash } = extractContractHashes(payload);
     const compressedCompiledContract = parseContract(contract);
-    if (typeof compiledClassHash === "undefined" && (details.version === "0x100000000000000000000000000000003" /* F3 */ || details.version === "0x3" /* V3 */)) {
+    if (typeof compiledClassHash === "undefined" && (details.version === api_exports.ETransactionVersion3.F3 || details.version === api_exports.ETransactionVersion3.V3)) {
       throw Error("V3 Transaction work with Cairo1 Contracts and require compiledClassHash");
     }
     const signature = !details.skipValidate ? await this.signer.signDeclareTransaction({
@@ -6673,7 +6699,6 @@ var AccountInterface = class extends ProviderInterface {
 var connect_exports = {};
 __export(connect_exports, {
   addDeclareTransaction: () => addDeclareTransaction,
-  addDeployAccountTransaction: () => addDeployAccountTransaction,
   addInvokeTransaction: () => addInvokeTransaction,
   addStarknetChain: () => addStarknetChain,
   deploymentData: () => deploymentData,
@@ -6687,11 +6712,11 @@ __export(connect_exports, {
   switchStarknetChain: () => switchStarknetChain,
   watchAsset: () => watchAsset
 });
-function requestAccounts(swo, silentMode = false) {
+function requestAccounts(swo, silent_mode = false) {
   return swo.request({
     type: "wallet_requestAccounts",
     params: {
-      silentMode
+      silent_mode
     }
   });
 }
@@ -6726,30 +6751,24 @@ function deploymentData(swo) {
 }
 function addInvokeTransaction(swo, params) {
   return swo.request({
-    type: "starknet_addInvokeTransaction",
+    type: "wallet_addInvokeTransaction",
     params
   });
 }
 function addDeclareTransaction(swo, params) {
   return swo.request({
-    type: "starknet_addDeclareTransaction",
-    params
-  });
-}
-function addDeployAccountTransaction(swo, params) {
-  return swo.request({
-    type: "starknet_addDeployAccountTransaction",
+    type: "wallet_addDeclareTransaction",
     params
   });
 }
 function signMessage(swo, typedData) {
   return swo.request({
-    type: "starknet_signTypedData",
+    type: "wallet_signTypedData",
     params: typedData
   });
 }
 function supportedSpecs(swo) {
-  return swo.request({ type: "starknet_supportedSpecs" });
+  return swo.request({ type: "wallet_supportedSpecs" });
 }
 function onAccountChange(swo, callback) {
   swo.on("accountsChanged", callback);
@@ -6778,7 +6797,7 @@ var WalletAccount = class extends Account {
     walletProvider.request({
       type: "wallet_requestAccounts",
       params: {
-        silentMode: false
+        silent_mode: false
       }
     }).then((res) => {
       this.address = res[0].toLowerCase();
@@ -6819,7 +6838,7 @@ var WalletAccount = class extends Account {
       const { contractAddress, entrypoint, calldata } = it;
       return {
         contract_address: contractAddress,
-        entrypoint,
+        entry_point: entrypoint,
         calldata
       };
     });
@@ -6852,14 +6871,6 @@ var WalletAccount = class extends Account {
       contract_address: addresses
     };
   }
-  deployAccount(payload) {
-    const params = {
-      contract_address_salt: payload.addressSalt?.toString() || "0",
-      constructor_calldata: payload.constructorCalldata ? CallData.compile(payload.constructorCalldata) : [],
-      class_hash: payload.classHash
-    };
-    return addDeployAccountTransaction(this.walletProvider, params);
-  }
   signMessage(typedData) {
     return signMessage(this.walletProvider, typedData);
   }
@@ -7258,7 +7269,7 @@ var ContractFactory = class {
 };
 
 // src/utils/address.ts
-var import_utils2 = require("@noble/curves/abstract/utils");
+var import_utils3 = require("@noble/curves/abstract/utils");
 function addAddressPadding(address) {
   return addHexPrefix(removeHexPrefix(toHex(address)).padStart(64, "0"));
 }
@@ -7273,7 +7284,7 @@ function validateAndParseAddress(address) {
 function getChecksumAddress(address) {
   const chars = removeHexPrefix(validateAndParseAddress(address)).toLowerCase().split("");
   const hex = removeHexPrefix(keccakBn(address));
-  const hashed = (0, import_utils2.hexToBytes)(hex.padStart(64, "0"));
+  const hashed = (0, import_utils3.hexToBytes)(hex.padStart(64, "0"));
   for (let i = 0; i < chars.length; i += 2) {
     if (hashed[i >> 1] >> 4 >= 8) {
       chars[i] = chars[i].toUpperCase();
@@ -7351,7 +7362,6 @@ var number = num_exports;
   ReceiptTx,
   RpcChannel,
   RpcProvider,
-  SIMULATION_FLAG,
   Signer,
   SignerInterface,
   TransactionExecutionStatus,
@@ -7395,6 +7405,7 @@ var number = num_exports;
   merkle,
   num,
   number,
+  parseCalldataField,
   parseUDCEvent,
   provider,
   selector,