starknet 6.7.0 → 6.9.0

package/dist/index.global.js

@@ -12324,9 +12324,9 @@ var starknet = (() => {
     var form = new FormData();
     body.trim().split("&").forEach(function(bytes3) {
       if (bytes3) {
-        var split2 = bytes3.split("=");
-        var name = split2.shift().replace(/\+/g, " ");
-        var value = split2.join("=").replace(/\+/g, " ");
+        var split3 = bytes3.split("=");
+        var name = split3.shift().replace(/\+/g, " ");
+        var value = split3.join("=").replace(/\+/g, " ");
         form.append(decodeURIComponent(name), decodeURIComponent(value));
       }
     });
@@ -12696,13 +12696,12 @@ var starknet = (() => {
     Literal: () => Literal,
     Provider: () => RpcProvider2,
     ProviderInterface: () => ProviderInterface,
-    RPC: () => api_exports,
+    RPC: () => api_exports2,
     RPC06: () => rpc_0_6_exports,
     RPC07: () => rpc_0_7_exports,
     ReceiptTx: () => ReceiptTx,
     RpcChannel: () => RpcChannel2,
     RpcProvider: () => RpcProvider2,
-    SIMULATION_FLAG: () => SIMULATION_FLAG,
     Signer: () => Signer,
     SignerInterface: () => SignerInterface,
     TransactionExecutionStatus: () => TransactionExecutionStatus,
@@ -12746,6 +12745,7 @@ var starknet = (() => {
     merkle: () => merkle_exports,
     num: () => num_exports,
     number: () => number3,
+    parseCalldataField: () => parseCalldataField,
     parseUDCEvent: () => parseUDCEvent,
     provider: () => provider_exports,
     selector: () => selector_exports,
@@ -12790,8 +12790,9 @@ var starknet = (() => {
   });
 
   // src/types/api/index.ts
-  var api_exports = {};
-  __export(api_exports, {
+  var api_exports2 = {};
+  __export(api_exports2, {
+    API: () => api_exports,
     EBlockTag: () => EBlockTag2,
     EDAMode: () => EDAMode2,
     EDataAvailabilityMode: () => EDataAvailabilityMode2,
@@ -12805,9 +12806,12 @@ var starknet = (() => {
     ETransactionVersion3: () => ETransactionVersion32,
     Errors: () => errors_exports2,
     JRPC: () => jsonrpc_exports,
+    Permission: () => Permission,
     RPCSPEC06: () => rpcspec_0_6_exports,
-    RPCSPEC07: () => rpcspec_0_7_exports,
-    SPEC: () => components_exports2
+    RPCSPEC07: () => esm_exports,
+    SPEC: () => components_exports2,
+    TypedDataRevision: () => TypedDataRevision,
+    WALLET_API: () => wallet_api_exports
   });
 
   // src/types/api/jsonrpc/index.ts
@@ -12909,9 +12913,31 @@ var starknet = (() => {
     return ETransactionVersion34;
   })(ETransactionVersion3 || {});
 
-  // src/types/api/rpcspec_0_7/index.ts
-  var rpcspec_0_7_exports = {};
-  __export(rpcspec_0_7_exports, {
+  // node_modules/starknet-types-07/dist/esm/index.js
+  var esm_exports = {};
+  __export(esm_exports, {
+    API: () => 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,
+    Permission: () => Permission,
+    SPEC: () => components_exports2,
+    TypedDataRevision: () => TypedDataRevision,
+    WALLET_API: () => wallet_api_exports
+  });
+
+  // node_modules/starknet-types-07/dist/esm/api/index.js
+  var api_exports = {};
+  __export(api_exports, {
     EBlockTag: () => EBlockTag2,
     EDAMode: () => EDAMode2,
     EDataAvailabilityMode: () => EDataAvailabilityMode2,
@@ -12927,59 +12953,60 @@ var starknet = (() => {
     SPEC: () => components_exports2
   });
 
-  // src/types/api/rpcspec_0_7/errors.ts
+  // node_modules/starknet-types-07/dist/esm/api/errors.js
   var errors_exports2 = {};
 
-  // src/types/api/rpcspec_0_7/components.ts
+  // node_modules/starknet-types-07/dist/esm/api/components.js
   var components_exports2 = {};
 
-  // src/types/api/rpcspec_0_7/nonspec.ts
-  var ETransactionType2 = /* @__PURE__ */ ((ETransactionType3) => {
+  // 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";
-    return ETransactionType3;
-  })(ETransactionType2 || {});
-  var ESimulationFlag2 = /* @__PURE__ */ ((ESimulationFlag3) => {
+  })(ETransactionType2 || (ETransactionType2 = {}));
+  var ESimulationFlag2;
+  (function(ESimulationFlag3) {
     ESimulationFlag3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
     ESimulationFlag3["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
-    return ESimulationFlag3;
-  })(ESimulationFlag2 || {});
-  var ETransactionStatus2 = /* @__PURE__ */ ((ETransactionStatus3) => {
+  })(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";
-    return ETransactionStatus3;
-  })(ETransactionStatus2 || {});
-  var ETransactionFinalityStatus2 = /* @__PURE__ */ ((ETransactionFinalityStatus3) => {
+  })(ETransactionStatus2 || (ETransactionStatus2 = {}));
+  var ETransactionFinalityStatus2;
+  (function(ETransactionFinalityStatus3) {
     ETransactionFinalityStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
     ETransactionFinalityStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    return ETransactionFinalityStatus3;
-  })(ETransactionFinalityStatus2 || {});
-  var ETransactionExecutionStatus2 = /* @__PURE__ */ ((ETransactionExecutionStatus3) => {
+  })(ETransactionFinalityStatus2 || (ETransactionFinalityStatus2 = {}));
+  var ETransactionExecutionStatus2;
+  (function(ETransactionExecutionStatus3) {
     ETransactionExecutionStatus3["SUCCEEDED"] = "SUCCEEDED";
     ETransactionExecutionStatus3["REVERTED"] = "REVERTED";
-    return ETransactionExecutionStatus3;
-  })(ETransactionExecutionStatus2 || {});
-  var EBlockTag2 = /* @__PURE__ */ ((EBlockTag3) => {
+  })(ETransactionExecutionStatus2 || (ETransactionExecutionStatus2 = {}));
+  var EBlockTag2;
+  (function(EBlockTag3) {
     EBlockTag3["LATEST"] = "latest";
     EBlockTag3["PENDING"] = "pending";
-    return EBlockTag3;
-  })(EBlockTag2 || {});
-  var EDataAvailabilityMode2 = /* @__PURE__ */ ((EDataAvailabilityMode3) => {
+  })(EBlockTag2 || (EBlockTag2 = {}));
+  var EDataAvailabilityMode2;
+  (function(EDataAvailabilityMode3) {
     EDataAvailabilityMode3["L1"] = "L1";
     EDataAvailabilityMode3["L2"] = "L2";
-    return EDataAvailabilityMode3;
-  })(EDataAvailabilityMode2 || {});
-  var EDAMode2 = /* @__PURE__ */ ((EDAMode4) => {
+  })(EDataAvailabilityMode2 || (EDataAvailabilityMode2 = {}));
+  var EDAMode2;
+  (function(EDAMode4) {
     EDAMode4[EDAMode4["L1"] = 0] = "L1";
     EDAMode4[EDAMode4["L2"] = 1] = "L2";
-    return EDAMode4;
-  })(EDAMode2 || {});
-  var ETransactionVersion4 = /* @__PURE__ */ ((ETransactionVersion5) => {
+  })(EDAMode2 || (EDAMode2 = {}));
+  var ETransactionVersion4;
+  (function(ETransactionVersion5) {
     ETransactionVersion5["V0"] = "0x0";
     ETransactionVersion5["V1"] = "0x1";
     ETransactionVersion5["V2"] = "0x2";
@@ -12988,22 +13015,41 @@ var starknet = (() => {
     ETransactionVersion5["F1"] = "0x100000000000000000000000000000001";
     ETransactionVersion5["F2"] = "0x100000000000000000000000000000002";
     ETransactionVersion5["F3"] = "0x100000000000000000000000000000003";
-    return ETransactionVersion5;
-  })(ETransactionVersion4 || {});
-  var ETransactionVersion22 = /* @__PURE__ */ ((ETransactionVersion24) => {
+  })(ETransactionVersion4 || (ETransactionVersion4 = {}));
+  var ETransactionVersion22;
+  (function(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) => {
+  })(ETransactionVersion22 || (ETransactionVersion22 = {}));
+  var ETransactionVersion32;
+  (function(ETransactionVersion34) {
     ETransactionVersion34["V3"] = "0x3";
     ETransactionVersion34["F3"] = "0x100000000000000000000000000000003";
-    return ETransactionVersion34;
-  })(ETransactionVersion32 || {});
+  })(ETransactionVersion32 || (ETransactionVersion32 = {}));
+
+  // node_modules/starknet-types-07/dist/esm/wallet-api/index.js
+  var wallet_api_exports = {};
+  __export(wallet_api_exports, {
+    Permission: () => Permission,
+    TypedDataRevision: () => TypedDataRevision
+  });
+
+  // node_modules/starknet-types-07/dist/esm/wallet-api/constants.js
+  var Permission;
+  (function(Permission2) {
+    Permission2["Accounts"] = "accounts";
+  })(Permission || (Permission = {}));
+
+  // node_modules/starknet-types-07/dist/esm/wallet-api/typedData.js
+  var TypedDataRevision;
+  (function(TypedDataRevision2) {
+    TypedDataRevision2["Active"] = "1";
+    TypedDataRevision2["Legacy"] = "0";
+  })(TypedDataRevision || (TypedDataRevision = {}));
 
   // src/utils/encode.ts
   var encode_exports = {};
@@ -13252,19 +13298,16 @@ var starknet = (() => {
   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 || {});
@@ -13288,10 +13331,6 @@ var starknet = (() => {
   };
   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}`
@@ -13302,188 +13341,6 @@ var starknet = (() => {
     ]
   };
 
-  // src/provider/errors.ts
-  function fixStack(target, fn = target.constructor) {
-    const { captureStackTrace } = Error;
-    captureStackTrace && captureStackTrace(target, fn);
-  }
-  function fixProto(target, prototype) {
-    const { setPrototypeOf } = Object;
-    setPrototypeOf ? setPrototypeOf(target, prototype) : target.__proto__ = prototype;
-  }
-  var CustomError = class extends Error {
-    name;
-    constructor(message) {
-      super(message);
-      Object.defineProperty(this, "name", {
-        value: new.target.name,
-        enumerable: false,
-        configurable: true
-      });
-      fixProto(this, new.target.prototype);
-      fixStack(this);
-    }
-  };
-  var LibraryError = class extends CustomError {
-  };
-  var GatewayError = class extends LibraryError {
-    constructor(message, errorCode) {
-      super(message);
-      this.errorCode = errorCode;
-    }
-  };
-  var HttpError = class extends LibraryError {
-    constructor(message, errorCode) {
-      super(message);
-      this.errorCode = errorCode;
-    }
-  };
-
-  // 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, {
-    BlockStatus: () => BlockStatus,
-    BlockTag: () => BlockTag,
-    EntryPointType: () => EntryPointType,
-    Literal: () => Literal,
-    RPC: () => api_exports,
-    SIMULATION_FLAG: () => SIMULATION_FLAG,
-    TransactionExecutionStatus: () => TransactionExecutionStatus,
-    TransactionFinalityStatus: () => TransactionFinalityStatus,
-    TransactionStatus: () => TransactionStatus,
-    TransactionType: () => TransactionType,
-    TypedDataRevision: () => 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";
-    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 || {});
-
-  // src/types/lib/contract/index.ts
-  var EntryPointType = /* @__PURE__ */ ((EntryPointType2) => {
-    EntryPointType2["EXTERNAL"] = "EXTERNAL";
-    EntryPointType2["L1_HANDLER"] = "L1_HANDLER";
-    EntryPointType2["CONSTRUCTOR"] = "CONSTRUCTOR";
-    return EntryPointType2;
-  })(EntryPointType || {});
-
-  // 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 || {});
-
-  // node_modules/starknet-types/dist/esm/common/typedData.js
-  var TypedDataRevision;
-  (function(TypedDataRevision2) {
-    TypedDataRevision2["Active"] = "1";
-    TypedDataRevision2["Legacy"] = "0";
-  })(TypedDataRevision || (TypedDataRevision = {}));
-
-  // src/utils/assert.ts
-  function assert(condition, message) {
-    if (!condition) {
-      throw new Error(message || "Assertion failure");
-    }
-  }
-
-  // src/utils/num.ts
-  var num_exports = {};
-  __export(num_exports, {
-    addPercent: () => addPercent,
-    assertInRange: () => assertInRange,
-    bigNumberishArrayToDecimalStringArray: () => bigNumberishArrayToDecimalStringArray,
-    bigNumberishArrayToHexadecimalStringArray: () => bigNumberishArrayToHexadecimalStringArray,
-    cleanHex: () => cleanHex,
-    getDecimalString: () => getDecimalString,
-    getHexString: () => getHexString,
-    getHexStringArray: () => getHexStringArray,
-    hexToBytes: () => hexToBytes2,
-    hexToDecimalString: () => hexToDecimalString,
-    isBigInt: () => isBigInt,
-    isBoolean: () => isBoolean,
-    isHex: () => isHex,
-    isNumber: () => isNumber,
-    isStringWholeNumber: () => isStringWholeNumber,
-    toBigInt: () => toBigInt,
-    toCairoBool: () => toCairoBool,
-    toHex: () => toHex,
-    toHexString: () => toHexString,
-    toStorageKey: () => toStorageKey
-  });
-
   // node_modules/@noble/curves/esm/abstract/utils.js
   var utils_exports = {};
   __export(utils_exports, {
@@ -13667,7 +13524,7 @@ var starknet = (() => {
       k = h(u8fr([1]), seed);
       v = h();
     };
-    const gen2 = () => {
+    const gen3 = () => {
       if (i++ >= 1e3)
         throw new Error("drbg: tried 1000 values");
       let len = 0;
@@ -13684,7 +13541,7 @@ var starknet = (() => {
       reset();
       reseed(seed);
       let res = void 0;
-      while (!(res = pred(gen2())))
+      while (!(res = pred(gen3())))
         reseed();
       reset();
       return res;
@@ -13721,7 +13578,484 @@ var starknet = (() => {
     return object;
   }
 
+  // node_modules/@noble/hashes/esm/_assert.js
+  function number(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+      throw new Error(`positive integer expected, not ${n}`);
+  }
+  function isBytes3(a) {
+    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+  }
+  function bytes(b, ...lengths) {
+    if (!isBytes3(b))
+      throw new Error("Uint8Array expected");
+    if (lengths.length > 0 && !lengths.includes(b.length))
+      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
+  }
+  function hash(h) {
+    if (typeof h !== "function" || typeof h.create !== "function")
+      throw new Error("Hash should be wrapped by utils.wrapConstructor");
+    number(h.outputLen);
+    number(h.blockLen);
+  }
+  function exists(instance, checkFinished = true) {
+    if (instance.destroyed)
+      throw new Error("Hash instance has been destroyed");
+    if (checkFinished && instance.finished)
+      throw new Error("Hash#digest() has already been called");
+  }
+  function output(out, instance) {
+    bytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+    }
+  }
+
+  // node_modules/@noble/hashes/esm/_u64.js
+  var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+  var _32n = /* @__PURE__ */ BigInt(32);
+  function fromBig(n, le = false) {
+    if (le)
+      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+  }
+  function split(lst, le = false) {
+    let Ah = new Uint32Array(lst.length);
+    let Al = new Uint32Array(lst.length);
+    for (let i = 0; i < lst.length; i++) {
+      const { h, l } = fromBig(lst[i], le);
+      [Ah[i], Al[i]] = [h, l];
+    }
+    return [Ah, Al];
+  }
+  var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+  var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+  var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+  var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+
+  // node_modules/@noble/hashes/esm/crypto.js
+  var crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+
+  // node_modules/@noble/hashes/esm/utils.js
+  var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+  var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+  var rotr = (word, shift) => word << 32 - shift | word >>> shift;
+  var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+  var byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+  function byteSwap32(arr) {
+    for (let i = 0; i < arr.length; i++) {
+      arr[i] = byteSwap(arr[i]);
+    }
+  }
+  function utf8ToBytes2(str) {
+    if (typeof str !== "string")
+      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+    return new Uint8Array(new TextEncoder().encode(str));
+  }
+  function toBytes(data) {
+    if (typeof data === "string")
+      data = utf8ToBytes2(data);
+    bytes(data);
+    return data;
+  }
+  function concatBytes2(...arrays) {
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      bytes(a);
+      sum += a.length;
+    }
+    const res = new Uint8Array(sum);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      res.set(a, pad);
+      pad += a.length;
+    }
+    return res;
+  }
+  var Hash = class {
+    // Safe version that clones internal state
+    clone() {
+      return this._cloneInto();
+    }
+  };
+  var toStr = {}.toString;
+  function wrapConstructor(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+    const tmp = hashCons();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashCons();
+    return hashC;
+  }
+  function wrapXOFConstructorWithOpts(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+  }
+  function randomBytes(bytesLength = 32) {
+    if (crypto && typeof crypto.getRandomValues === "function") {
+      return crypto.getRandomValues(new Uint8Array(bytesLength));
+    }
+    throw new Error("crypto.getRandomValues must be defined");
+  }
+
+  // node_modules/@noble/hashes/esm/sha3.js
+  var SHA3_PI = [];
+  var SHA3_ROTL = [];
+  var _SHA3_IOTA = [];
+  var _0n2 = /* @__PURE__ */ BigInt(0);
+  var _1n2 = /* @__PURE__ */ BigInt(1);
+  var _2n2 = /* @__PURE__ */ BigInt(2);
+  var _7n = /* @__PURE__ */ BigInt(7);
+  var _256n = /* @__PURE__ */ BigInt(256);
+  var _0x71n = /* @__PURE__ */ BigInt(113);
+  for (let round = 0, R = _1n2, x = 1, y = 0; round < 24; round++) {
+    [x, y] = [y, (2 * x + 3 * y) % 5];
+    SHA3_PI.push(2 * (5 * y + x));
+    SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+    let t = _0n2;
+    for (let j = 0; j < 7; j++) {
+      R = (R << _1n2 ^ (R >> _7n) * _0x71n) % _256n;
+      if (R & _2n2)
+        t ^= _1n2 << (_1n2 << /* @__PURE__ */ BigInt(j)) - _1n2;
+    }
+    _SHA3_IOTA.push(t);
+  }
+  var [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
+  var rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+  var rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+  function keccakP(s, rounds = 24) {
+    const B = new Uint32Array(5 * 2);
+    for (let round = 24 - rounds; round < 24; round++) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+      for (let x = 0; x < 10; x += 2) {
+        const idx1 = (x + 8) % 10;
+        const idx0 = (x + 2) % 10;
+        const B0 = B[idx0];
+        const B1 = B[idx0 + 1];
+        const Th = rotlH(B0, B1, 1) ^ B[idx1];
+        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+        for (let y = 0; y < 50; y += 10) {
+          s[x + y] ^= Th;
+          s[x + y + 1] ^= Tl;
+        }
+      }
+      let curH = s[2];
+      let curL = s[3];
+      for (let t = 0; t < 24; t++) {
+        const shift = SHA3_ROTL[t];
+        const Th = rotlH(curH, curL, shift);
+        const Tl = rotlL(curH, curL, shift);
+        const PI = SHA3_PI[t];
+        curH = s[PI];
+        curL = s[PI + 1];
+        s[PI] = Th;
+        s[PI + 1] = Tl;
+      }
+      for (let y = 0; y < 50; y += 10) {
+        for (let x = 0; x < 10; x++)
+          B[x] = s[y + x];
+        for (let x = 0; x < 10; x++)
+          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+      }
+      s[0] ^= SHA3_IOTA_H[round];
+      s[1] ^= SHA3_IOTA_L[round];
+    }
+    B.fill(0);
+  }
+  var Keccak = class _Keccak extends Hash {
+    // NOTE: we accept arguments in bytes instead of bits here.
+    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+      super();
+      this.blockLen = blockLen;
+      this.suffix = suffix;
+      this.outputLen = outputLen;
+      this.enableXOF = enableXOF;
+      this.rounds = rounds;
+      this.pos = 0;
+      this.posOut = 0;
+      this.finished = false;
+      this.destroyed = false;
+      number(outputLen);
+      if (0 >= this.blockLen || this.blockLen >= 200)
+        throw new Error("Sha3 supports only keccak-f1600 function");
+      this.state = new Uint8Array(200);
+      this.state32 = u32(this.state);
+    }
+    keccak() {
+      if (!isLE)
+        byteSwap32(this.state32);
+      keccakP(this.state32, this.rounds);
+      if (!isLE)
+        byteSwap32(this.state32);
+      this.posOut = 0;
+      this.pos = 0;
+    }
+    update(data) {
+      exists(this);
+      const { blockLen, state } = this;
+      data = toBytes(data);
+      const len = data.length;
+      for (let pos = 0; pos < len; ) {
+        const take = Math.min(blockLen - this.pos, len - pos);
+        for (let i = 0; i < take; i++)
+          state[this.pos++] ^= data[pos++];
+        if (this.pos === blockLen)
+          this.keccak();
+      }
+      return this;
+    }
+    finish() {
+      if (this.finished)
+        return;
+      this.finished = true;
+      const { state, suffix, pos, blockLen } = this;
+      state[pos] ^= suffix;
+      if ((suffix & 128) !== 0 && pos === blockLen - 1)
+        this.keccak();
+      state[blockLen - 1] ^= 128;
+      this.keccak();
+    }
+    writeInto(out) {
+      exists(this, false);
+      bytes(out);
+      this.finish();
+      const bufferOut = this.state;
+      const { blockLen } = this;
+      for (let pos = 0, len = out.length; pos < len; ) {
+        if (this.posOut >= blockLen)
+          this.keccak();
+        const take = Math.min(blockLen - this.posOut, len - pos);
+        out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+        this.posOut += take;
+        pos += take;
+      }
+      return out;
+    }
+    xofInto(out) {
+      if (!this.enableXOF)
+        throw new Error("XOF is not possible for this instance");
+      return this.writeInto(out);
+    }
+    xof(bytes3) {
+      number(bytes3);
+      return this.xofInto(new Uint8Array(bytes3));
+    }
+    digestInto(out) {
+      output(out, this);
+      if (this.finished)
+        throw new Error("digest() was already called");
+      this.writeInto(out);
+      this.destroy();
+      return out;
+    }
+    digest() {
+      return this.digestInto(new Uint8Array(this.outputLen));
+    }
+    destroy() {
+      this.destroyed = true;
+      this.state.fill(0);
+    }
+    _cloneInto(to) {
+      const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+      to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+      to.state32.set(this.state32);
+      to.pos = this.pos;
+      to.posOut = this.posOut;
+      to.finished = this.finished;
+      to.rounds = rounds;
+      to.suffix = suffix;
+      to.outputLen = outputLen;
+      to.enableXOF = enableXOF;
+      to.destroyed = this.destroyed;
+      return to;
+    }
+  };
+  var gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
+  var sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
+  var sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
+  var sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
+  var sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
+  var keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
+  var keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
+  var keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
+  var keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
+  var genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+  var shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
+  var shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
+
+  // 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;
+    captureStackTrace && captureStackTrace(target, fn);
+  }
+  function fixProto(target, prototype) {
+    const { setPrototypeOf } = Object;
+    setPrototypeOf ? setPrototypeOf(target, prototype) : target.__proto__ = prototype;
+  }
+  var CustomError = class extends Error {
+    name;
+    constructor(message) {
+      super(message);
+      Object.defineProperty(this, "name", {
+        value: new.target.name,
+        enumerable: false,
+        configurable: true
+      });
+      fixProto(this, new.target.prototype);
+      fixStack(this);
+    }
+  };
+  var LibraryError = class extends CustomError {
+  };
+  var GatewayError = class extends LibraryError {
+    constructor(message, errorCode) {
+      super(message);
+      this.errorCode = errorCode;
+    }
+  };
+  var HttpError = class extends LibraryError {
+    constructor(message, errorCode) {
+      super(message);
+      this.errorCode = errorCode;
+    }
+  };
+
+  // src/types/index.ts
+  var types_exports = {};
+  __export(types_exports, {
+    BlockStatus: () => BlockStatus,
+    BlockTag: () => BlockTag,
+    EntryPointType: () => EntryPointType,
+    Literal: () => Literal,
+    RPC: () => api_exports2,
+    TransactionExecutionStatus: () => TransactionExecutionStatus,
+    TransactionFinalityStatus: () => TransactionFinalityStatus,
+    TransactionStatus: () => TransactionStatus,
+    TransactionType: () => TransactionType,
+    TypedDataRevision: () => TypedDataRevision,
+    Uint: () => Uint,
+    ValidateType: () => ValidateType
+  });
+
+  // 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 || {});
+
+  // src/types/lib/contract/index.ts
+  var EntryPointType = /* @__PURE__ */ ((EntryPointType2) => {
+    EntryPointType2["EXTERNAL"] = "EXTERNAL";
+    EntryPointType2["L1_HANDLER"] = "L1_HANDLER";
+    EntryPointType2["CONSTRUCTOR"] = "CONSTRUCTOR";
+    return EntryPointType2;
+  })(EntryPointType || {});
+
+  // 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 || {});
+
+  // src/utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failure");
+    }
+  }
+
   // src/utils/num.ts
+  var num_exports = {};
+  __export(num_exports, {
+    addPercent: () => addPercent,
+    assertInRange: () => assertInRange,
+    bigNumberishArrayToDecimalStringArray: () => bigNumberishArrayToDecimalStringArray,
+    bigNumberishArrayToHexadecimalStringArray: () => bigNumberishArrayToHexadecimalStringArray,
+    cleanHex: () => cleanHex,
+    getDecimalString: () => getDecimalString,
+    getHexString: () => getHexString,
+    getHexStringArray: () => getHexStringArray,
+    hexToBytes: () => hexToBytes2,
+    hexToDecimalString: () => hexToDecimalString,
+    isBigInt: () => isBigInt,
+    isBoolean: () => isBoolean,
+    isHex: () => isHex,
+    isNumber: () => isNumber,
+    isStringWholeNumber: () => isStringWholeNumber,
+    toBigInt: () => toBigInt,
+    toCairoBool: () => toCairoBool,
+    toHex: () => toHex,
+    toHexString: () => toHexString,
+    toStorageKey: () => toStorageKey
+  });
   function isHex(hex) {
     return /^0x[0-9a-f]*$/i.test(hex);
   }
@@ -13812,8 +14146,8 @@ var starknet = (() => {
   });
 
   // node_modules/@scure/starknet/lib/esm/index.js
-  var esm_exports = {};
-  __export(esm_exports, {
+  var esm_exports2 = {};
+  __export(esm_exports2, {
     CURVE: () => CURVE,
     Fp251: () => Fp251,
     MAX_VALUE: () => MAX_VALUE,
@@ -13842,92 +14176,92 @@ var starknet = (() => {
     verify: () => verify
   });
 
-  // node_modules/@noble/hashes/esm/_assert.js
-  function number(n) {
+  // node_modules/@scure/starknet/node_modules/@noble/hashes/esm/_assert.js
+  function number2(n) {
     if (!Number.isSafeInteger(n) || n < 0)
       throw new Error(`Wrong positive integer: ${n}`);
   }
-  function isBytes3(a) {
+  function isBytes4(a) {
     return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
   }
-  function bytes(b, ...lengths) {
-    if (!isBytes3(b))
+  function bytes2(b, ...lengths) {
+    if (!isBytes4(b))
       throw new Error("Expected Uint8Array");
     if (lengths.length > 0 && !lengths.includes(b.length))
       throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
   }
-  function hash(hash3) {
+  function hash2(hash3) {
     if (typeof hash3 !== "function" || typeof hash3.create !== "function")
       throw new Error("Hash should be wrapped by utils.wrapConstructor");
-    number(hash3.outputLen);
-    number(hash3.blockLen);
+    number2(hash3.outputLen);
+    number2(hash3.blockLen);
   }
-  function exists(instance, checkFinished = true) {
+  function exists2(instance, checkFinished = true) {
     if (instance.destroyed)
       throw new Error("Hash instance has been destroyed");
     if (checkFinished && instance.finished)
       throw new Error("Hash#digest() has already been called");
   }
-  function output(out, instance) {
-    bytes(out);
+  function output2(out, instance) {
+    bytes2(out);
     const min = instance.outputLen;
     if (out.length < min) {
       throw new Error(`digestInto() expects output buffer of length at least ${min}`);
     }
   }
 
-  // node_modules/@noble/hashes/esm/_u64.js
-  var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
-  var _32n = /* @__PURE__ */ BigInt(32);
-  function fromBig(n, le = false) {
+  // node_modules/@scure/starknet/node_modules/@noble/hashes/esm/_u64.js
+  var U32_MASK642 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+  var _32n2 = /* @__PURE__ */ BigInt(32);
+  function fromBig2(n, le = false) {
     if (le)
-      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
-    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+      return { h: Number(n & U32_MASK642), l: Number(n >> _32n2 & U32_MASK642) };
+    return { h: Number(n >> _32n2 & U32_MASK642) | 0, l: Number(n & U32_MASK642) | 0 };
   }
-  function split(lst, le = false) {
+  function split2(lst, le = false) {
     let Ah = new Uint32Array(lst.length);
     let Al = new Uint32Array(lst.length);
     for (let i = 0; i < lst.length; i++) {
-      const { h, l } = fromBig(lst[i], le);
+      const { h, l } = fromBig2(lst[i], le);
       [Ah[i], Al[i]] = [h, l];
     }
     return [Ah, Al];
   }
-  var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
-  var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
-  var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
-  var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+  var rotlSH2 = (h, l, s) => h << s | l >>> 32 - s;
+  var rotlSL2 = (h, l, s) => l << s | h >>> 32 - s;
+  var rotlBH2 = (h, l, s) => l << s - 32 | h >>> 64 - s;
+  var rotlBL2 = (h, l, s) => h << s - 32 | l >>> 64 - s;
 
-  // node_modules/@noble/hashes/esm/crypto.js
-  var crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+  // node_modules/@scure/starknet/node_modules/@noble/hashes/esm/crypto.js
+  var crypto2 = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
 
-  // node_modules/@noble/hashes/esm/utils.js
-  var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-  function isBytes4(a) {
+  // node_modules/@scure/starknet/node_modules/@noble/hashes/esm/utils.js
+  var u322 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+  function isBytes5(a) {
     return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
   }
-  var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-  var rotr = (word, shift) => word << 32 - shift | word >>> shift;
-  var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-  if (!isLE)
+  var createView2 = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+  var rotr2 = (word, shift) => word << 32 - shift | word >>> shift;
+  var isLE2 = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+  if (!isLE2)
     throw new Error("Non little-endian hardware is not supported");
-  function utf8ToBytes2(str) {
+  function utf8ToBytes3(str) {
     if (typeof str !== "string")
       throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
     return new Uint8Array(new TextEncoder().encode(str));
   }
-  function toBytes(data) {
+  function toBytes2(data) {
     if (typeof data === "string")
-      data = utf8ToBytes2(data);
-    if (!isBytes4(data))
+      data = utf8ToBytes3(data);
+    if (!isBytes5(data))
       throw new Error(`expected Uint8Array, got ${typeof data}`);
     return data;
   }
-  function concatBytes2(...arrays) {
+  function concatBytes3(...arrays) {
     let sum = 0;
     for (let i = 0; i < arrays.length; i++) {
       const a = arrays[i];
-      if (!isBytes4(a))
+      if (!isBytes5(a))
         throw new Error("Uint8Array expected");
       sum += a.length;
     }
@@ -13939,60 +14273,60 @@ var starknet = (() => {
     }
     return res;
   }
-  var Hash = class {
+  var Hash2 = class {
     // Safe version that clones internal state
     clone() {
       return this._cloneInto();
     }
   };
-  var toStr = {}.toString;
-  function wrapConstructor(hashCons) {
-    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  var toStr2 = {}.toString;
+  function wrapConstructor2(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
     const tmp = hashCons();
     hashC.outputLen = tmp.outputLen;
     hashC.blockLen = tmp.blockLen;
     hashC.create = () => hashCons();
     return hashC;
   }
-  function wrapXOFConstructorWithOpts(hashCons) {
-    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+  function wrapXOFConstructorWithOpts2(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
     const tmp = hashCons({});
     hashC.outputLen = tmp.outputLen;
     hashC.blockLen = tmp.blockLen;
     hashC.create = (opts) => hashCons(opts);
     return hashC;
   }
-  function randomBytes(bytesLength = 32) {
-    if (crypto && typeof crypto.getRandomValues === "function") {
-      return crypto.getRandomValues(new Uint8Array(bytesLength));
+  function randomBytes2(bytesLength = 32) {
+    if (crypto2 && typeof crypto2.getRandomValues === "function") {
+      return crypto2.getRandomValues(new Uint8Array(bytesLength));
     }
     throw new Error("crypto.getRandomValues must be defined");
   }
 
-  // node_modules/@noble/hashes/esm/sha3.js
-  var [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
-  var _0n2 = /* @__PURE__ */ BigInt(0);
-  var _1n2 = /* @__PURE__ */ BigInt(1);
-  var _2n2 = /* @__PURE__ */ BigInt(2);
-  var _7n = /* @__PURE__ */ BigInt(7);
-  var _256n = /* @__PURE__ */ BigInt(256);
-  var _0x71n = /* @__PURE__ */ BigInt(113);
-  for (let round = 0, R = _1n2, x = 1, y = 0; round < 24; round++) {
+  // node_modules/@scure/starknet/node_modules/@noble/hashes/esm/sha3.js
+  var [SHA3_PI2, SHA3_ROTL2, _SHA3_IOTA2] = [[], [], []];
+  var _0n3 = /* @__PURE__ */ BigInt(0);
+  var _1n3 = /* @__PURE__ */ BigInt(1);
+  var _2n3 = /* @__PURE__ */ BigInt(2);
+  var _7n2 = /* @__PURE__ */ BigInt(7);
+  var _256n2 = /* @__PURE__ */ BigInt(256);
+  var _0x71n2 = /* @__PURE__ */ BigInt(113);
+  for (let round = 0, R = _1n3, x = 1, y = 0; round < 24; round++) {
     [x, y] = [y, (2 * x + 3 * y) % 5];
-    SHA3_PI.push(2 * (5 * y + x));
-    SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
-    let t = _0n2;
+    SHA3_PI2.push(2 * (5 * y + x));
+    SHA3_ROTL2.push((round + 1) * (round + 2) / 2 % 64);
+    let t = _0n3;
     for (let j = 0; j < 7; j++) {
-      R = (R << _1n2 ^ (R >> _7n) * _0x71n) % _256n;
-      if (R & _2n2)
-        t ^= _1n2 << (_1n2 << /* @__PURE__ */ BigInt(j)) - _1n2;
+      R = (R << _1n3 ^ (R >> _7n2) * _0x71n2) % _256n2;
+      if (R & _2n3)
+        t ^= _1n3 << (_1n3 << /* @__PURE__ */ BigInt(j)) - _1n3;
     }
-    _SHA3_IOTA.push(t);
+    _SHA3_IOTA2.push(t);
   }
-  var [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
-  var rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
-  var rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
-  function keccakP(s, rounds = 24) {
+  var [SHA3_IOTA_H2, SHA3_IOTA_L2] = /* @__PURE__ */ split2(_SHA3_IOTA2, true);
+  var rotlH2 = (h, l, s) => s > 32 ? rotlBH2(h, l, s) : rotlSH2(h, l, s);
+  var rotlL2 = (h, l, s) => s > 32 ? rotlBL2(h, l, s) : rotlSL2(h, l, s);
+  function keccakP2(s, rounds = 24) {
     const B = new Uint32Array(5 * 2);
     for (let round = 24 - rounds; round < 24; round++) {
       for (let x = 0; x < 10; x++)
@@ -14002,8 +14336,8 @@ var starknet = (() => {
         const idx0 = (x + 2) % 10;
         const B0 = B[idx0];
         const B1 = B[idx0 + 1];
-        const Th = rotlH(B0, B1, 1) ^ B[idx1];
-        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+        const Th = rotlH2(B0, B1, 1) ^ B[idx1];
+        const Tl = rotlL2(B0, B1, 1) ^ B[idx1 + 1];
         for (let y = 0; y < 50; y += 10) {
           s[x + y] ^= Th;
           s[x + y + 1] ^= Tl;
@@ -14012,10 +14346,10 @@ var starknet = (() => {
       let curH = s[2];
       let curL = s[3];
       for (let t = 0; t < 24; t++) {
-        const shift = SHA3_ROTL[t];
-        const Th = rotlH(curH, curL, shift);
-        const Tl = rotlL(curH, curL, shift);
-        const PI = SHA3_PI[t];
+        const shift = SHA3_ROTL2[t];
+        const Th = rotlH2(curH, curL, shift);
+        const Tl = rotlL2(curH, curL, shift);
+        const PI = SHA3_PI2[t];
         curH = s[PI];
         curL = s[PI + 1];
         s[PI] = Th;
@@ -14027,12 +14361,12 @@ var starknet = (() => {
         for (let x = 0; x < 10; x++)
           s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
       }
-      s[0] ^= SHA3_IOTA_H[round];
-      s[1] ^= SHA3_IOTA_L[round];
+      s[0] ^= SHA3_IOTA_H2[round];
+      s[1] ^= SHA3_IOTA_L2[round];
     }
     B.fill(0);
   }
-  var Keccak = class _Keccak extends Hash {
+  var Keccak2 = class _Keccak extends Hash2 {
     // NOTE: we accept arguments in bytes instead of bits here.
     constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
       super();
@@ -14045,21 +14379,21 @@ var starknet = (() => {
       this.posOut = 0;
       this.finished = false;
       this.destroyed = false;
-      number(outputLen);
+      number2(outputLen);
       if (0 >= this.blockLen || this.blockLen >= 200)
         throw new Error("Sha3 supports only keccak-f1600 function");
       this.state = new Uint8Array(200);
-      this.state32 = u32(this.state);
+      this.state32 = u322(this.state);
     }
     keccak() {
-      keccakP(this.state32, this.rounds);
+      keccakP2(this.state32, this.rounds);
       this.posOut = 0;
       this.pos = 0;
     }
     update(data) {
-      exists(this);
+      exists2(this);
       const { blockLen, state } = this;
-      data = toBytes(data);
+      data = toBytes2(data);
       const len = data.length;
       for (let pos = 0; pos < len; ) {
         const take = Math.min(blockLen - this.pos, len - pos);
@@ -14082,8 +14416,8 @@ var starknet = (() => {
       this.keccak();
     }
     writeInto(out) {
-      exists(this, false);
-      bytes(out);
+      exists2(this, false);
+      bytes2(out);
       this.finish();
       const bufferOut = this.state;
       const { blockLen } = this;
@@ -14103,11 +14437,11 @@ var starknet = (() => {
       return this.writeInto(out);
     }
     xof(bytes3) {
-      number(bytes3);
+      number2(bytes3);
       return this.xofInto(new Uint8Array(bytes3));
     }
     digestInto(out) {
-      output(out, this);
+      output2(out, this);
       if (this.finished)
         throw new Error("digest() was already called");
       this.writeInto(out);
@@ -14136,33 +14470,33 @@ var starknet = (() => {
       return to;
     }
   };
-  var gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
-  var sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
-  var sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
-  var sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
-  var sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
-  var keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
-  var keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
-  var keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
-  var keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
-  var genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
-  var shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
-  var shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
+  var gen2 = (suffix, blockLen, outputLen) => wrapConstructor2(() => new Keccak2(blockLen, suffix, outputLen));
+  var sha3_2242 = /* @__PURE__ */ gen2(6, 144, 224 / 8);
+  var sha3_2562 = /* @__PURE__ */ gen2(6, 136, 256 / 8);
+  var sha3_3842 = /* @__PURE__ */ gen2(6, 104, 384 / 8);
+  var sha3_5122 = /* @__PURE__ */ gen2(6, 72, 512 / 8);
+  var keccak_2242 = /* @__PURE__ */ gen2(1, 144, 224 / 8);
+  var keccak_2562 = /* @__PURE__ */ gen2(1, 136, 256 / 8);
+  var keccak_3842 = /* @__PURE__ */ gen2(1, 104, 384 / 8);
+  var keccak_5122 = /* @__PURE__ */ gen2(1, 72, 512 / 8);
+  var genShake2 = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts2((opts = {}) => new Keccak2(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+  var shake1282 = /* @__PURE__ */ genShake2(31, 168, 128 / 8);
+  var shake2562 = /* @__PURE__ */ genShake2(31, 136, 256 / 8);
 
-  // node_modules/@noble/hashes/esm/_sha2.js
+  // node_modules/@scure/starknet/node_modules/@noble/hashes/esm/_sha2.js
   function setBigUint64(view, byteOffset, value, isLE3) {
     if (typeof view.setBigUint64 === "function")
       return view.setBigUint64(byteOffset, value, isLE3);
-    const _32n2 = BigInt(32);
+    const _32n3 = BigInt(32);
     const _u32_max = BigInt(4294967295);
-    const wh = Number(value >> _32n2 & _u32_max);
+    const wh = Number(value >> _32n3 & _u32_max);
     const wl = Number(value & _u32_max);
     const h = isLE3 ? 4 : 0;
     const l = isLE3 ? 0 : 4;
     view.setUint32(byteOffset + h, wh, isLE3);
     view.setUint32(byteOffset + l, wl, isLE3);
   }
-  var SHA2 = class extends Hash {
+  var SHA2 = class extends Hash2 {
     constructor(blockLen, outputLen, padOffset, isLE3) {
       super();
       this.blockLen = blockLen;
@@ -14174,17 +14508,17 @@ var starknet = (() => {
       this.pos = 0;
       this.destroyed = false;
       this.buffer = new Uint8Array(blockLen);
-      this.view = createView(this.buffer);
+      this.view = createView2(this.buffer);
     }
     update(data) {
-      exists(this);
+      exists2(this);
       const { view, buffer, blockLen } = this;
-      data = toBytes(data);
+      data = toBytes2(data);
       const len = data.length;
       for (let pos = 0; pos < len; ) {
         const take = Math.min(blockLen - this.pos, len - pos);
         if (take === blockLen) {
-          const dataView = createView(data);
+          const dataView = createView2(data);
           for (; blockLen <= len - pos; pos += blockLen)
             this.process(dataView, pos);
           continue;
@@ -14202,8 +14536,8 @@ var starknet = (() => {
       return this;
     }
     digestInto(out) {
-      exists(this);
-      output(out, this);
+      exists2(this);
+      output2(out, this);
       this.finished = true;
       const { buffer, view, blockLen, isLE: isLE3 } = this;
       let { pos } = this;
@@ -14217,7 +14551,7 @@ var starknet = (() => {
         buffer[i] = 0;
       setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE3);
       this.process(view, 0);
-      const oview = createView(out);
+      const oview = createView2(out);
       const len = this.outputLen;
       if (len % 4)
         throw new Error("_sha2: outputLen should be aligned to 32bit");
@@ -14249,7 +14583,7 @@ var starknet = (() => {
     }
   };
 
-  // node_modules/@noble/hashes/esm/sha256.js
+  // node_modules/@scure/starknet/node_modules/@noble/hashes/esm/sha256.js
   var Chi = (a, b, c) => a & b ^ ~a & c;
   var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
   var SHA256_K = /* @__PURE__ */ new Uint32Array([
@@ -14362,15 +14696,15 @@ var starknet = (() => {
       for (let i = 16; i < 64; i++) {
         const W15 = SHA256_W[i - 15];
         const W2 = SHA256_W[i - 2];
-        const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-        const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+        const s0 = rotr2(W15, 7) ^ rotr2(W15, 18) ^ W15 >>> 3;
+        const s1 = rotr2(W2, 17) ^ rotr2(W2, 19) ^ W2 >>> 10;
         SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
       }
       let { A, B, C, D, E, F, G, H } = this;
       for (let i = 0; i < 64; i++) {
-        const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+        const sigma1 = rotr2(E, 6) ^ rotr2(E, 11) ^ rotr2(E, 25);
         const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-        const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+        const sigma0 = rotr2(A, 2) ^ rotr2(A, 13) ^ rotr2(A, 22);
         const T2 = sigma0 + Maj(A, B, C) | 0;
         H = G;
         G = F;
@@ -14399,7 +14733,7 @@ var starknet = (() => {
       this.buffer.fill(0);
     }
   };
-  var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
+  var sha256 = /* @__PURE__ */ wrapConstructor2(() => new SHA256());
 
   // node_modules/@scure/starknet/node_modules/@noble/curves/esm/abstract/utils.js
   var utils_exports2 = {};
@@ -14411,29 +14745,29 @@ var starknet = (() => {
     bytesToHex: () => bytesToHex2,
     bytesToNumberBE: () => bytesToNumberBE2,
     bytesToNumberLE: () => bytesToNumberLE2,
-    concatBytes: () => concatBytes3,
+    concatBytes: () => concatBytes4,
     createHmacDrbg: () => createHmacDrbg2,
     ensureBytes: () => ensureBytes2,
     equalBytes: () => equalBytes2,
     hexToBytes: () => hexToBytes3,
     hexToNumber: () => hexToNumber2,
-    isBytes: () => isBytes5,
+    isBytes: () => isBytes6,
     numberToBytesBE: () => numberToBytesBE2,
     numberToBytesLE: () => numberToBytesLE2,
     numberToHexUnpadded: () => numberToHexUnpadded2,
     numberToVarBytesBE: () => numberToVarBytesBE2,
-    utf8ToBytes: () => utf8ToBytes3,
+    utf8ToBytes: () => utf8ToBytes4,
     validateObject: () => validateObject2
   });
-  var _0n3 = BigInt(0);
-  var _1n3 = BigInt(1);
-  var _2n3 = BigInt(2);
-  function isBytes5(a) {
+  var _0n4 = BigInt(0);
+  var _1n4 = BigInt(1);
+  var _2n4 = BigInt(2);
+  function isBytes6(a) {
     return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
   }
   var hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
   function bytesToHex2(bytes3) {
-    if (!isBytes5(bytes3))
+    if (!isBytes6(bytes3))
       throw new Error("Uint8Array expected");
     let hex = "";
     for (let i = 0; i < bytes3.length; i++) {
@@ -14483,7 +14817,7 @@ var starknet = (() => {
     return hexToNumber2(bytesToHex2(bytes3));
   }
   function bytesToNumberLE2(bytes3) {
-    if (!isBytes5(bytes3))
+    if (!isBytes6(bytes3))
       throw new Error("Uint8Array expected");
     return hexToNumber2(bytesToHex2(Uint8Array.from(bytes3).reverse()));
   }
@@ -14504,7 +14838,7 @@ var starknet = (() => {
       } catch (e) {
         throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
       }
-    } else if (isBytes5(hex)) {
+    } else if (isBytes6(hex)) {
       res = Uint8Array.from(hex);
     } else {
       throw new Error(`${title} must be hex string or Uint8Array`);
@@ -14514,11 +14848,11 @@ var starknet = (() => {
       throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
     return res;
   }
-  function concatBytes3(...arrays) {
+  function concatBytes4(...arrays) {
     let sum = 0;
     for (let i = 0; i < arrays.length; i++) {
       const a = arrays[i];
-      if (!isBytes5(a))
+      if (!isBytes6(a))
         throw new Error("Uint8Array expected");
       sum += a.length;
     }
@@ -14539,24 +14873,24 @@ var starknet = (() => {
       diff |= a[i] ^ b[i];
     return diff === 0;
   }
-  function utf8ToBytes3(str) {
+  function utf8ToBytes4(str) {
     if (typeof str !== "string")
       throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
     return new Uint8Array(new TextEncoder().encode(str));
   }
   function bitLen2(n) {
     let len;
-    for (len = 0; n > _0n3; n >>= _1n3, len += 1)
+    for (len = 0; n > _0n4; n >>= _1n4, len += 1)
       ;
     return len;
   }
   function bitGet2(n, pos) {
-    return n >> BigInt(pos) & _1n3;
+    return n >> BigInt(pos) & _1n4;
   }
   var bitSet2 = (n, pos, value) => {
-    return n | (value ? _1n3 : _0n3) << BigInt(pos);
+    return n | (value ? _1n4 : _0n4) << BigInt(pos);
   };
-  var bitMask2 = (n) => (_2n3 << BigInt(n - 1)) - _1n3;
+  var bitMask2 = (n) => (_2n4 << BigInt(n - 1)) - _1n4;
   var u8n2 = (data) => new Uint8Array(data);
   var u8fr2 = (arr) => Uint8Array.from(arr);
   function createHmacDrbg2(hashLen, qByteLen, hmacFn) {
@@ -14583,7 +14917,7 @@ var starknet = (() => {
       k = h(u8fr2([1]), seed);
       v = h();
     };
-    const gen2 = () => {
+    const gen3 = () => {
       if (i++ >= 1e3)
         throw new Error("drbg: tried 1000 values");
       let len = 0;
@@ -14594,13 +14928,13 @@ var starknet = (() => {
         out.push(sl);
         len += v.length;
       }
-      return concatBytes3(...out);
+      return concatBytes4(...out);
     };
     const genUntil = (seed, pred) => {
       reset();
       reseed(seed);
       let res = void 0;
-      while (!(res = pred(gen2())))
+      while (!(res = pred(gen3())))
         reseed();
       reset();
       return res;
@@ -14612,7 +14946,7 @@ var starknet = (() => {
     function: (val) => typeof val === "function",
     boolean: (val) => typeof val === "boolean",
     string: (val) => typeof val === "string",
-    stringOrUint8Array: (val) => typeof val === "string" || isBytes5(val),
+    stringOrUint8Array: (val) => typeof val === "string" || isBytes6(val),
     isSafeInteger: (val) => Number.isSafeInteger(val),
     array: (val) => Array.isArray(val),
     field: (val, object) => object.Fp.isValid(val),
@@ -14638,9 +14972,9 @@ var starknet = (() => {
   }
 
   // node_modules/@scure/starknet/node_modules/@noble/curves/esm/abstract/modular.js
-  var _0n4 = BigInt(0);
-  var _1n4 = BigInt(1);
-  var _2n4 = BigInt(2);
+  var _0n5 = BigInt(0);
+  var _1n5 = BigInt(1);
+  var _2n5 = BigInt(2);
   var _3n = BigInt(3);
   var _4n = BigInt(4);
   var _5n = BigInt(5);
@@ -14649,30 +14983,30 @@ var starknet = (() => {
   var _16n = BigInt(16);
   function mod(a, b) {
     const result = a % b;
-    return result >= _0n4 ? result : b + result;
+    return result >= _0n5 ? result : b + result;
   }
   function pow(num, power, modulo) {
-    if (modulo <= _0n4 || power < _0n4)
+    if (modulo <= _0n5 || power < _0n5)
       throw new Error("Expected power/modulo > 0");
-    if (modulo === _1n4)
-      return _0n4;
-    let res = _1n4;
-    while (power > _0n4) {
-      if (power & _1n4)
+    if (modulo === _1n5)
+      return _0n5;
+    let res = _1n5;
+    while (power > _0n5) {
+      if (power & _1n5)
         res = res * num % modulo;
       num = num * num % modulo;
-      power >>= _1n4;
+      power >>= _1n5;
     }
     return res;
   }
   function invert(number4, modulo) {
-    if (number4 === _0n4 || modulo <= _0n4) {
+    if (number4 === _0n5 || modulo <= _0n5) {
       throw new Error(`invert: expected positive integers, got n=${number4} mod=${modulo}`);
     }
     let a = mod(number4, modulo);
     let b = modulo;
-    let x = _0n4, y = _1n4, u = _1n4, v = _0n4;
-    while (a !== _0n4) {
+    let x = _0n5, y = _1n5, u = _1n5, v = _0n5;
+    while (a !== _0n5) {
       const q = b / a;
       const r = b % a;
       const m = x - u * q;
@@ -14680,19 +15014,19 @@ var starknet = (() => {
       b = a, a = r, x = u, y = v, u = m, v = n;
     }
     const gcd2 = b;
-    if (gcd2 !== _1n4)
+    if (gcd2 !== _1n5)
       throw new Error("invert: does not exist");
     return mod(x, modulo);
   }
   function tonelliShanks(P) {
-    const legendreC = (P - _1n4) / _2n4;
+    const legendreC = (P - _1n5) / _2n5;
     let Q, S, Z;
-    for (Q = P - _1n4, S = 0; Q % _2n4 === _0n4; Q /= _2n4, S++)
+    for (Q = P - _1n5, S = 0; Q % _2n5 === _0n5; Q /= _2n5, S++)
       ;
-    for (Z = _2n4; Z < P && pow(Z, legendreC, P) !== P - _1n4; Z++)
+    for (Z = _2n5; Z < P && pow(Z, legendreC, P) !== P - _1n5; Z++)
       ;
     if (S === 1) {
-      const p1div4 = (P + _1n4) / _4n;
+      const p1div4 = (P + _1n5) / _4n;
       return function tonelliFast(Fp2, n) {
         const root = Fp2.pow(n, p1div4);
         if (!Fp2.eql(Fp2.sqr(root), n))
@@ -14700,7 +15034,7 @@ var starknet = (() => {
         return root;
       };
     }
-    const Q1div2 = (Q + _1n4) / _2n4;
+    const Q1div2 = (Q + _1n5) / _2n5;
     return function tonelliSlow(Fp2, n) {
       if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
         throw new Error("Cannot find square root");
@@ -14717,7 +15051,7 @@ var starknet = (() => {
             break;
           t2 = Fp2.sqr(t2);
         }
-        const ge = Fp2.pow(g2, _1n4 << BigInt(r - m - 1));
+        const ge = Fp2.pow(g2, _1n5 << BigInt(r - m - 1));
         g2 = Fp2.sqr(ge);
         x = Fp2.mul(x, ge);
         b = Fp2.mul(b, g2);
@@ -14728,7 +15062,7 @@ var starknet = (() => {
   }
   function FpSqrt(P) {
     if (P % _4n === _3n) {
-      const p1div4 = (P + _1n4) / _4n;
+      const p1div4 = (P + _1n5) / _4n;
       return function sqrt3mod4(Fp2, n) {
         const root = Fp2.pow(n, p1div4);
         if (!Fp2.eql(Fp2.sqr(root), n))
@@ -14739,10 +15073,10 @@ var starknet = (() => {
     if (P % _8n === _5n) {
       const c1 = (P - _5n) / _8n;
       return function sqrt5mod8(Fp2, n) {
-        const n2 = Fp2.mul(n, _2n4);
+        const n2 = Fp2.mul(n, _2n5);
         const v = Fp2.pow(n2, c1);
         const nv = Fp2.mul(n, v);
-        const i = Fp2.mul(Fp2.mul(nv, _2n4), v);
+        const i = Fp2.mul(Fp2.mul(nv, _2n5), v);
         const root = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
         if (!Fp2.eql(Fp2.sqr(root), n))
           throw new Error("Cannot find square root");
@@ -14786,19 +15120,19 @@ var starknet = (() => {
     return validateObject2(field, opts);
   }
   function FpPow(f, num, power) {
-    if (power < _0n4)
+    if (power < _0n5)
       throw new Error("Expected power > 0");
-    if (power === _0n4)
+    if (power === _0n5)
       return f.ONE;
-    if (power === _1n4)
+    if (power === _1n5)
       return num;
     let p = f.ONE;
     let d = num;
-    while (power > _0n4) {
-      if (power & _1n4)
+    while (power > _0n5) {
+      if (power & _1n5)
         p = f.mul(p, d);
       d = f.sqr(d);
-      power >>= _1n4;
+      power >>= _1n5;
     }
     return p;
   }
@@ -14825,7 +15159,7 @@ var starknet = (() => {
     return { nBitLength: _nBitLength, nByteLength };
   }
   function Field(ORDER, bitLen3, isLE3 = false, redef = {}) {
-    if (ORDER <= _0n4)
+    if (ORDER <= _0n5)
       throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
     const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen3);
     if (BYTES > 2048)
@@ -14836,16 +15170,16 @@ var starknet = (() => {
       BITS,
       BYTES,
       MASK: bitMask2(BITS),
-      ZERO: _0n4,
-      ONE: _1n4,
+      ZERO: _0n5,
+      ONE: _1n5,
       create: (num) => mod(num, ORDER),
       isValid: (num) => {
         if (typeof num !== "bigint")
           throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);
-        return _0n4 <= num && num < ORDER;
+        return _0n5 <= num && num < ORDER;
       },
-      is0: (num) => num === _0n4,
-      isOdd: (num) => (num & _1n4) === _1n4,
+      is0: (num) => num === _0n5,
+      isOdd: (num) => (num & _1n5) === _1n5,
       neg: (num) => mod(-num, ORDER),
       eql: (lhs, rhs) => lhs === rhs,
       sqr: (num) => mod(num * num, ORDER),
@@ -14891,7 +15225,7 @@ var starknet = (() => {
     if (len < 16 || len < minLen || len > 1024)
       throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
     const num = isLE3 ? bytesToNumberBE2(key) : bytesToNumberLE2(key);
-    const reduced = mod(num, fieldOrder - _1n4) + _1n4;
+    const reduced = mod(num, fieldOrder - _1n5) + _1n5;
     return isLE3 ? numberToBytesLE2(reduced, fieldLen) : numberToBytesBE2(reduced, fieldLen);
   }
 
@@ -14979,8 +15313,8 @@ var starknet = (() => {
   }
 
   // node_modules/@scure/starknet/node_modules/@noble/curves/esm/abstract/curve.js
-  var _0n5 = BigInt(0);
-  var _1n5 = BigInt(1);
+  var _0n6 = BigInt(0);
+  var _1n6 = BigInt(1);
   function wNAF(c, bits) {
     const constTimeNegate = (condition, item) => {
       const neg = item.negate();
@@ -14997,11 +15331,11 @@ var starknet = (() => {
       unsafeLadder(elm, n) {
         let p = c.ZERO;
         let d = elm;
-        while (n > _0n5) {
-          if (n & _1n5)
+        while (n > _0n6) {
+          if (n & _1n6)
             p = p.add(d);
           d = d.double();
-          n >>= _1n5;
+          n >>= _1n6;
         }
         return p;
       },
@@ -15051,7 +15385,7 @@ var starknet = (() => {
           n >>= shiftBy;
           if (wbits > windowSize) {
             wbits -= maxNumber;
-            n += _1n5;
+            n += _1n6;
           }
           const offset1 = offset;
           const offset2 = offset + Math.abs(wbits) - 1;
@@ -15147,7 +15481,7 @@ var starknet = (() => {
     toSig(hex) {
       const { Err: E } = DER;
       const data = typeof hex === "string" ? h2b(hex) : hex;
-      if (!isBytes5(data))
+      if (!isBytes6(data))
         throw new Error("ui8a expected");
       let l = data.length;
       if (l < 2 || data[0] != 48)
@@ -15175,9 +15509,9 @@ var starknet = (() => {
       return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
     }
   };
-  var _0n6 = BigInt(0);
-  var _1n6 = BigInt(1);
-  var _2n5 = BigInt(2);
+  var _0n7 = BigInt(0);
+  var _1n7 = BigInt(1);
+  var _2n6 = BigInt(2);
   var _3n2 = BigInt(3);
   var _4n2 = BigInt(4);
   function weierstrassPoints(opts) {
@@ -15185,7 +15519,7 @@ var starknet = (() => {
     const { Fp: Fp2 } = CURVE2;
     const toBytes3 = CURVE2.toBytes || ((_c, point, _isCompressed) => {
       const a = point.toAffine();
-      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
+      return concatBytes4(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
     });
     const fromBytes = CURVE2.fromBytes || ((bytes3) => {
       const tail = bytes3.subarray(1);
@@ -15202,7 +15536,7 @@ var starknet = (() => {
     if (!Fp2.eql(Fp2.sqr(CURVE2.Gy), weierstrassEquation(CURVE2.Gx)))
       throw new Error("bad generator point: equation left != right");
     function isWithinCurveOrder(num) {
-      return typeof num === "bigint" && _0n6 < num && num < CURVE2.n;
+      return typeof num === "bigint" && _0n7 < num && num < CURVE2.n;
     }
     function assertGE(num) {
       if (!isWithinCurveOrder(num))
@@ -15211,7 +15545,7 @@ var starknet = (() => {
     function normPrivateKeyToScalar(key) {
       const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE2;
       if (lengths && typeof key !== "bigint") {
-        if (isBytes5(key))
+        if (isBytes6(key))
           key = bytesToHex2(key);
         if (typeof key !== "string" || !lengths.includes(key.length))
           throw new Error("Invalid key");
@@ -15446,10 +15780,10 @@ var starknet = (() => {
        */
       multiplyUnsafe(n) {
         const I = Point2.ZERO;
-        if (n === _0n6)
+        if (n === _0n7)
           return I;
         assertGE(n);
-        if (n === _1n6)
+        if (n === _1n7)
           return this;
         const { endo } = CURVE2;
         if (!endo)
@@ -15458,14 +15792,14 @@ var starknet = (() => {
         let k1p = I;
         let k2p = I;
         let d = this;
-        while (k1 > _0n6 || k2 > _0n6) {
-          if (k1 & _1n6)
+        while (k1 > _0n7 || k2 > _0n7) {
+          if (k1 & _1n7)
             k1p = k1p.add(d);
-          if (k2 & _1n6)
+          if (k2 & _1n7)
             k2p = k2p.add(d);
           d = d.double();
-          k1 >>= _1n6;
-          k2 >>= _1n6;
+          k1 >>= _1n7;
+          k2 >>= _1n7;
         }
         if (k1neg)
           k1p = k1p.negate();
@@ -15512,7 +15846,7 @@ var starknet = (() => {
        */
       multiplyAndAddUnsafe(Q, a, b) {
         const G = Point2.BASE;
-        const mul = (P, a2) => a2 === _0n6 || a2 === _1n6 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
+        const mul = (P, a2) => a2 === _0n7 || a2 === _1n7 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
         const sum = mul(this, a).add(mul(Q, b));
         return sum.is0() ? void 0 : sum;
       }
@@ -15535,7 +15869,7 @@ var starknet = (() => {
       }
       isTorsionFree() {
         const { h: cofactor, isTorsionFree } = CURVE2;
-        if (cofactor === _1n6)
+        if (cofactor === _1n7)
           return true;
         if (isTorsionFree)
           return isTorsionFree(Point2, this);
@@ -15543,7 +15877,7 @@ var starknet = (() => {
       }
       clearCofactor() {
         const { h: cofactor, clearCofactor } = CURVE2;
-        if (cofactor === _1n6)
+        if (cofactor === _1n7)
           return this;
         if (clearCofactor)
           return clearCofactor(Point2, this);
@@ -15588,7 +15922,7 @@ var starknet = (() => {
     const compressedLen = Fp2.BYTES + 1;
     const uncompressedLen = 2 * Fp2.BYTES + 1;
     function isValidFieldElement(num) {
-      return _0n6 < num && num < Fp2.ORDER;
+      return _0n7 < num && num < Fp2.ORDER;
     }
     function modN(a) {
       return mod(a, CURVE_ORDER2);
@@ -15601,7 +15935,7 @@ var starknet = (() => {
       toBytes(_c, point, isCompressed) {
         const a = point.toAffine();
         const x = Fp2.toBytes(a.x);
-        const cat = concatBytes3;
+        const cat = concatBytes4;
         if (isCompressed) {
           return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
         } else {
@@ -15618,7 +15952,7 @@ var starknet = (() => {
             throw new Error("Point is not on curve");
           const y2 = weierstrassEquation(x);
           let y = Fp2.sqrt(y2);
-          const isYOdd = (y & _1n6) === _1n6;
+          const isYOdd = (y & _1n7) === _1n7;
           const isHeadOdd = (head & 1) === 1;
           if (isHeadOdd !== isYOdd)
             y = Fp2.neg(y);
@@ -15634,7 +15968,7 @@ var starknet = (() => {
     });
     const numToNByteStr = (num) => bytesToHex2(numberToBytesBE2(num, CURVE2.nByteLength));
     function isBiggerThanHalfOrder(number4) {
-      const HALF = CURVE_ORDER2 >> _1n6;
+      const HALF = CURVE_ORDER2 >> _1n7;
       return number4 > HALF;
     }
     function normalizeS(s) {
@@ -15746,7 +16080,7 @@ var starknet = (() => {
       return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
     }
     function isProbPub(item) {
-      const arr = isBytes5(item);
+      const arr = isBytes6(item);
       const str = typeof item === "string";
       const len = (arr || str) && item.length;
       if (arr)
@@ -15777,7 +16111,7 @@ var starknet = (() => {
     function int2octets(num) {
       if (typeof num !== "bigint")
         throw new Error("bigint expected");
-      if (!(_0n6 <= num && num < ORDER_MASK))
+      if (!(_0n7 <= num && num < ORDER_MASK))
         throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`);
       return numberToBytesBE2(num, CURVE2.nByteLength);
     }
@@ -15798,7 +16132,7 @@ var starknet = (() => {
         const e = ent === true ? randomBytes3(Fp2.BYTES) : ent;
         seedArgs.push(ensureBytes2("extraEntropy", e));
       }
-      const seed = concatBytes3(...seedArgs);
+      const seed = concatBytes4(...seedArgs);
       const m = h1int;
       function k2sig(kBytes) {
         const k = bits2int2(kBytes);
@@ -15807,12 +16141,12 @@ var starknet = (() => {
         const ik = invN(k);
         const q = Point2.BASE.multiply(k).toAffine();
         const r = modN(q.x);
-        if (r === _0n6)
+        if (r === _0n7)
           return;
         const s = modN(ik * modN(m + r * d));
-        if (s === _0n6)
+        if (s === _0n7)
           return;
-        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n6);
+        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n7);
         let normS = s;
         if (lowS && isBiggerThanHalfOrder(s)) {
           normS = normalizeS(s);
@@ -15841,7 +16175,7 @@ var starknet = (() => {
       let _sig = void 0;
       let P;
       try {
-        if (typeof sg === "string" || isBytes5(sg)) {
+        if (typeof sg === "string" || isBytes6(sg)) {
           try {
             _sig = Signature3.fromDER(sg);
           } catch (derError) {
@@ -15888,14 +16222,14 @@ var starknet = (() => {
     };
   }
 
-  // node_modules/@noble/hashes/esm/hmac.js
-  var HMAC = class extends Hash {
+  // node_modules/@scure/starknet/node_modules/@noble/hashes/esm/hmac.js
+  var HMAC = class extends Hash2 {
     constructor(hash3, _key) {
       super();
       this.finished = false;
       this.destroyed = false;
-      hash(hash3);
-      const key = toBytes(_key);
+      hash2(hash3);
+      const key = toBytes2(_key);
       this.iHash = hash3.create();
       if (typeof this.iHash.update !== "function")
         throw new Error("Expected instance of class which extends utils.Hash");
@@ -15914,13 +16248,13 @@ var starknet = (() => {
       pad.fill(0);
     }
     update(buf) {
-      exists(this);
+      exists2(this);
       this.iHash.update(buf);
       return this;
     }
     digestInto(out) {
-      exists(this);
-      bytes(out, this.outputLen);
+      exists2(this);
+      bytes2(out, this.outputLen);
       this.finished = true;
       this.iHash.digestInto(out);
       this.oHash.update(out);
@@ -15957,8 +16291,8 @@ var starknet = (() => {
   function getHash(hash3) {
     return {
       hash: hash3,
-      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes2(...msgs)),
-      randomBytes
+      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes3(...msgs)),
+      randomBytes: randomBytes2
     };
   }
 
@@ -16061,7 +16395,7 @@ var starknet = (() => {
     const sha256mask = 2n ** 256n;
     const limit = sha256mask - mod(sha256mask, CURVE_ORDER);
     for (let i = 0; ; i++) {
-      const key = sha256Num(concatBytes3(_seed, numberToVarBytesBE2(BigInt(i))));
+      const key = sha256Num(concatBytes4(_seed, numberToVarBytesBE2(BigInt(i))));
       if (key < limit)
         return mod(key, CURVE_ORDER).toString(16);
       if (i === 1e5)
@@ -16143,11 +16477,11 @@ var starknet = (() => {
   }
   var computeHashOnElements = (data, fn = pedersen) => [0, ...data, data.length].reduce((x, y) => fn(x, y));
   var MASK_2502 = bitMask2(250);
-  var keccak = (data) => bytesToNumberBE2(keccak_256(data)) & MASK_2502;
+  var keccak = (data) => bytesToNumberBE2(keccak_2562(data)) & MASK_2502;
   var sha256Num = (data) => bytesToNumberBE2(sha256(data));
   var Fp251 = Field(BigInt("3618502788666131213697322783095070105623107215331596699973092056135872020481"));
   function poseidonRoundConstant(Fp2, name, idx) {
-    const val = Fp2.fromBytes(sha256(utf8ToBytes2(`${name}${idx}`)));
+    const val = Fp2.fromBytes(sha256(utf8ToBytes3(`${name}${idx}`)));
     return Fp2.create(val);
   }
   function _poseidonMDS(Fp2, name, m, attempt = 0) {
@@ -16845,46 +17179,49 @@ var starknet = (() => {
     }
   };
   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
@@ -16939,7 +17276,9 @@ var starknet = (() => {
      * @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);
     }
     /**
@@ -17909,7 +18248,7 @@ var starknet = (() => {
      * 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
@@ -18154,9 +18493,9 @@ var starknet = (() => {
   });
 
   // node_modules/@noble/curves/esm/abstract/modular.js
-  var _0n7 = BigInt(0);
-  var _1n7 = BigInt(1);
-  var _2n6 = BigInt(2);
+  var _0n8 = BigInt(0);
+  var _1n8 = BigInt(1);
+  var _2n7 = BigInt(2);
   var _3n3 = BigInt(3);
   var _4n3 = BigInt(4);
   var _5n2 = BigInt(5);
@@ -18165,38 +18504,38 @@ var starknet = (() => {
   var _16n2 = BigInt(16);
   function mod2(a, b) {
     const result = a % b;
-    return result >= _0n7 ? result : b + result;
+    return result >= _0n8 ? result : b + result;
   }
   function pow2(num, power, modulo) {
-    if (modulo <= _0n7 || power < _0n7)
+    if (modulo <= _0n8 || power < _0n8)
       throw new Error("Expected power/modulo > 0");
-    if (modulo === _1n7)
-      return _0n7;
-    let res = _1n7;
-    while (power > _0n7) {
-      if (power & _1n7)
+    if (modulo === _1n8)
+      return _0n8;
+    let res = _1n8;
+    while (power > _0n8) {
+      if (power & _1n8)
         res = res * num % modulo;
       num = num * num % modulo;
-      power >>= _1n7;
+      power >>= _1n8;
     }
     return res;
   }
   function pow22(x, power, modulo) {
     let res = x;
-    while (power-- > _0n7) {
+    while (power-- > _0n8) {
       res *= res;
       res %= modulo;
     }
     return res;
   }
   function invert2(number4, modulo) {
-    if (number4 === _0n7 || modulo <= _0n7) {
+    if (number4 === _0n8 || modulo <= _0n8) {
       throw new Error(`invert: expected positive integers, got n=${number4} mod=${modulo}`);
     }
     let a = mod2(number4, modulo);
     let b = modulo;
-    let x = _0n7, y = _1n7, u = _1n7, v = _0n7;
-    while (a !== _0n7) {
+    let x = _0n8, y = _1n8, u = _1n8, v = _0n8;
+    while (a !== _0n8) {
       const q = b / a;
       const r = b % a;
       const m = x - u * q;
@@ -18204,19 +18543,19 @@ var starknet = (() => {
       b = a, a = r, x = u, y = v, u = m, v = n;
     }
     const gcd2 = b;
-    if (gcd2 !== _1n7)
+    if (gcd2 !== _1n8)
       throw new Error("invert: does not exist");
     return mod2(x, modulo);
   }
   function tonelliShanks2(P) {
-    const legendreC = (P - _1n7) / _2n6;
+    const legendreC = (P - _1n8) / _2n7;
     let Q, S, Z;
-    for (Q = P - _1n7, S = 0; Q % _2n6 === _0n7; Q /= _2n6, S++)
+    for (Q = P - _1n8, S = 0; Q % _2n7 === _0n8; Q /= _2n7, S++)
       ;
-    for (Z = _2n6; Z < P && pow2(Z, legendreC, P) !== P - _1n7; Z++)
+    for (Z = _2n7; Z < P && pow2(Z, legendreC, P) !== P - _1n8; Z++)
       ;
     if (S === 1) {
-      const p1div4 = (P + _1n7) / _4n3;
+      const p1div4 = (P + _1n8) / _4n3;
       return function tonelliFast(Fp2, n) {
         const root = Fp2.pow(n, p1div4);
         if (!Fp2.eql(Fp2.sqr(root), n))
@@ -18224,7 +18563,7 @@ var starknet = (() => {
         return root;
       };
     }
-    const Q1div2 = (Q + _1n7) / _2n6;
+    const Q1div2 = (Q + _1n8) / _2n7;
     return function tonelliSlow(Fp2, n) {
       if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
         throw new Error("Cannot find square root");
@@ -18241,7 +18580,7 @@ var starknet = (() => {
             break;
           t2 = Fp2.sqr(t2);
         }
-        const ge = Fp2.pow(g2, _1n7 << BigInt(r - m - 1));
+        const ge = Fp2.pow(g2, _1n8 << BigInt(r - m - 1));
         g2 = Fp2.sqr(ge);
         x = Fp2.mul(x, ge);
         b = Fp2.mul(b, g2);
@@ -18252,7 +18591,7 @@ var starknet = (() => {
   }
   function FpSqrt2(P) {
     if (P % _4n3 === _3n3) {
-      const p1div4 = (P + _1n7) / _4n3;
+      const p1div4 = (P + _1n8) / _4n3;
       return function sqrt3mod4(Fp2, n) {
         const root = Fp2.pow(n, p1div4);
         if (!Fp2.eql(Fp2.sqr(root), n))
@@ -18263,10 +18602,10 @@ var starknet = (() => {
     if (P % _8n2 === _5n2) {
       const c1 = (P - _5n2) / _8n2;
       return function sqrt5mod8(Fp2, n) {
-        const n2 = Fp2.mul(n, _2n6);
+        const n2 = Fp2.mul(n, _2n7);
         const v = Fp2.pow(n2, c1);
         const nv = Fp2.mul(n, v);
-        const i = Fp2.mul(Fp2.mul(nv, _2n6), v);
+        const i = Fp2.mul(Fp2.mul(nv, _2n7), v);
         const root = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
         if (!Fp2.eql(Fp2.sqr(root), n))
           throw new Error("Cannot find square root");
@@ -18310,19 +18649,19 @@ var starknet = (() => {
     return validateObject(field, opts);
   }
   function FpPow2(f, num, power) {
-    if (power < _0n7)
+    if (power < _0n8)
       throw new Error("Expected power > 0");
-    if (power === _0n7)
+    if (power === _0n8)
       return f.ONE;
-    if (power === _1n7)
+    if (power === _1n8)
       return num;
     let p = f.ONE;
     let d = num;
-    while (power > _0n7) {
-      if (power & _1n7)
+    while (power > _0n8) {
+      if (power & _1n8)
         p = f.mul(p, d);
       d = f.sqr(d);
-      power >>= _1n7;
+      power >>= _1n8;
     }
     return p;
   }
@@ -18349,7 +18688,7 @@ var starknet = (() => {
     return { nBitLength: _nBitLength, nByteLength };
   }
   function Field2(ORDER, bitLen3, isLE3 = false, redef = {}) {
-    if (ORDER <= _0n7)
+    if (ORDER <= _0n8)
       throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
     const { nBitLength: BITS, nByteLength: BYTES } = nLength2(ORDER, bitLen3);
     if (BYTES > 2048)
@@ -18360,16 +18699,16 @@ var starknet = (() => {
       BITS,
       BYTES,
       MASK: bitMask(BITS),
-      ZERO: _0n7,
-      ONE: _1n7,
+      ZERO: _0n8,
+      ONE: _1n8,
       create: (num) => mod2(num, ORDER),
       isValid: (num) => {
         if (typeof num !== "bigint")
           throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);
-        return _0n7 <= num && num < ORDER;
+        return _0n8 <= num && num < ORDER;
       },
-      is0: (num) => num === _0n7,
-      isOdd: (num) => (num & _1n7) === _1n7,
+      is0: (num) => num === _0n8,
+      isOdd: (num) => (num & _1n8) === _1n8,
       neg: (num) => mod2(-num, ORDER),
       eql: (lhs, rhs) => lhs === rhs,
       sqr: (num) => mod2(num * num, ORDER),
@@ -18415,7 +18754,7 @@ var starknet = (() => {
     if (len < 16 || len < minLen || len > 1024)
       throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
     const num = isLE3 ? bytesToNumberBE(key) : bytesToNumberLE(key);
-    const reduced = mod2(num, fieldOrder - _1n7) + _1n7;
+    const reduced = mod2(num, fieldOrder - _1n8) + _1n8;
     return isLE3 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
   }
 
@@ -18531,7 +18870,7 @@ var starknet = (() => {
   // src/utils/ec.ts
   var ec_exports = {};
   __export(ec_exports, {
-    starkCurve: () => esm_exports,
+    starkCurve: () => esm_exports2,
     weierstrass: () => weierstrass_exports
   });
 
@@ -18546,8 +18885,8 @@ var starknet = (() => {
   });
 
   // node_modules/@noble/curves/esm/abstract/curve.js
-  var _0n8 = BigInt(0);
-  var _1n8 = BigInt(1);
+  var _0n9 = BigInt(0);
+  var _1n9 = BigInt(1);
   function wNAF2(c, bits) {
     const constTimeNegate = (condition, item) => {
       const neg = item.negate();
@@ -18564,11 +18903,11 @@ var starknet = (() => {
       unsafeLadder(elm, n) {
         let p = c.ZERO;
         let d = elm;
-        while (n > _0n8) {
-          if (n & _1n8)
+        while (n > _0n9) {
+          if (n & _1n9)
             p = p.add(d);
           d = d.double();
-          n >>= _1n8;
+          n >>= _1n9;
         }
         return p;
       },
@@ -18618,7 +18957,7 @@ var starknet = (() => {
           n >>= shiftBy;
           if (wbits > windowSize) {
             wbits -= maxNumber;
-            n += _1n8;
+            n += _1n9;
           }
           const offset1 = offset;
           const offset2 = offset + Math.abs(wbits) - 1;
@@ -18741,9 +19080,9 @@ var starknet = (() => {
       return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
     }
   };
-  var _0n9 = BigInt(0);
-  var _1n9 = BigInt(1);
-  var _2n7 = BigInt(2);
+  var _0n10 = BigInt(0);
+  var _1n10 = BigInt(1);
+  var _2n8 = BigInt(2);
   var _3n4 = BigInt(3);
   var _4n4 = BigInt(4);
   function weierstrassPoints2(opts) {
@@ -18768,7 +19107,7 @@ var starknet = (() => {
     if (!Fp2.eql(Fp2.sqr(CURVE2.Gy), weierstrassEquation(CURVE2.Gx)))
       throw new Error("bad generator point: equation left != right");
     function isWithinCurveOrder(num) {
-      return typeof num === "bigint" && _0n9 < num && num < CURVE2.n;
+      return typeof num === "bigint" && _0n10 < num && num < CURVE2.n;
     }
     function assertGE(num) {
       if (!isWithinCurveOrder(num))
@@ -19012,10 +19351,10 @@ var starknet = (() => {
        */
       multiplyUnsafe(n) {
         const I = Point2.ZERO;
-        if (n === _0n9)
+        if (n === _0n10)
           return I;
         assertGE(n);
-        if (n === _1n9)
+        if (n === _1n10)
           return this;
         const { endo } = CURVE2;
         if (!endo)
@@ -19024,14 +19363,14 @@ var starknet = (() => {
         let k1p = I;
         let k2p = I;
         let d = this;
-        while (k1 > _0n9 || k2 > _0n9) {
-          if (k1 & _1n9)
+        while (k1 > _0n10 || k2 > _0n10) {
+          if (k1 & _1n10)
             k1p = k1p.add(d);
-          if (k2 & _1n9)
+          if (k2 & _1n10)
             k2p = k2p.add(d);
           d = d.double();
-          k1 >>= _1n9;
-          k2 >>= _1n9;
+          k1 >>= _1n10;
+          k2 >>= _1n10;
         }
         if (k1neg)
           k1p = k1p.negate();
@@ -19078,7 +19417,7 @@ var starknet = (() => {
        */
       multiplyAndAddUnsafe(Q, a, b) {
         const G = Point2.BASE;
-        const mul = (P, a2) => a2 === _0n9 || a2 === _1n9 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
+        const mul = (P, a2) => a2 === _0n10 || a2 === _1n10 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
         const sum = mul(this, a).add(mul(Q, b));
         return sum.is0() ? void 0 : sum;
       }
@@ -19101,7 +19440,7 @@ var starknet = (() => {
       }
       isTorsionFree() {
         const { h: cofactor, isTorsionFree } = CURVE2;
-        if (cofactor === _1n9)
+        if (cofactor === _1n10)
           return true;
         if (isTorsionFree)
           return isTorsionFree(Point2, this);
@@ -19109,7 +19448,7 @@ var starknet = (() => {
       }
       clearCofactor() {
         const { h: cofactor, clearCofactor } = CURVE2;
-        if (cofactor === _1n9)
+        if (cofactor === _1n10)
           return this;
         if (clearCofactor)
           return clearCofactor(Point2, this);
@@ -19154,7 +19493,7 @@ var starknet = (() => {
     const compressedLen = Fp2.BYTES + 1;
     const uncompressedLen = 2 * Fp2.BYTES + 1;
     function isValidFieldElement(num) {
-      return _0n9 < num && num < Fp2.ORDER;
+      return _0n10 < num && num < Fp2.ORDER;
     }
     function modN(a) {
       return mod2(a, CURVE_ORDER2);
@@ -19190,7 +19529,7 @@ var starknet = (() => {
             const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
             throw new Error("Point is not on curve" + suffix);
           }
-          const isYOdd = (y & _1n9) === _1n9;
+          const isYOdd = (y & _1n10) === _1n10;
           const isHeadOdd = (head & 1) === 1;
           if (isHeadOdd !== isYOdd)
             y = Fp2.neg(y);
@@ -19206,7 +19545,7 @@ var starknet = (() => {
     });
     const numToNByteStr = (num) => bytesToHex(numberToBytesBE(num, CURVE2.nByteLength));
     function isBiggerThanHalfOrder(number4) {
-      const HALF = CURVE_ORDER2 >> _1n9;
+      const HALF = CURVE_ORDER2 >> _1n10;
       return number4 > HALF;
     }
     function normalizeS(s) {
@@ -19349,7 +19688,7 @@ var starknet = (() => {
     function int2octets(num) {
       if (typeof num !== "bigint")
         throw new Error("bigint expected");
-      if (!(_0n9 <= num && num < ORDER_MASK))
+      if (!(_0n10 <= num && num < ORDER_MASK))
         throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`);
       return numberToBytesBE(num, CURVE2.nByteLength);
     }
@@ -19379,12 +19718,12 @@ var starknet = (() => {
         const ik = invN(k);
         const q = Point2.BASE.multiply(k).toAffine();
         const r = modN(q.x);
-        if (r === _0n9)
+        if (r === _0n10)
           return;
         const s = modN(ik * modN(m + r * d));
-        if (s === _0n9)
+        if (s === _0n10)
           return;
-        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n9);
+        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n10);
         let normS = s;
         if (lowS && isBiggerThanHalfOrder(s)) {
           normS = normalizeS(s);
@@ -19461,18 +19800,18 @@ var starknet = (() => {
   }
   function SWUFpSqrtRatio(Fp2, Z) {
     const q = Fp2.ORDER;
-    let l = _0n9;
-    for (let o = q - _1n9; o % _2n7 === _0n9; o /= _2n7)
-      l += _1n9;
+    let l = _0n10;
+    for (let o = q - _1n10; o % _2n8 === _0n10; o /= _2n8)
+      l += _1n10;
     const c1 = l;
-    const _2n_pow_c1_1 = _2n7 << c1 - _1n9 - _1n9;
-    const _2n_pow_c1 = _2n_pow_c1_1 * _2n7;
-    const c2 = (q - _1n9) / _2n_pow_c1;
-    const c3 = (c2 - _1n9) / _2n7;
-    const c4 = _2n_pow_c1 - _1n9;
+    const _2n_pow_c1_1 = _2n8 << c1 - _1n10 - _1n10;
+    const _2n_pow_c1 = _2n_pow_c1_1 * _2n8;
+    const c2 = (q - _1n10) / _2n_pow_c1;
+    const c3 = (c2 - _1n10) / _2n8;
+    const c4 = _2n_pow_c1 - _1n10;
     const c5 = _2n_pow_c1_1;
     const c6 = Fp2.pow(Z, c2);
-    const c7 = Fp2.pow(Z, (c2 + _1n9) / _2n7);
+    const c7 = Fp2.pow(Z, (c2 + _1n10) / _2n8);
     let sqrtRatio = (u, v) => {
       let tv1 = c6;
       let tv2 = Fp2.pow(v, c4);
@@ -19490,9 +19829,9 @@ var starknet = (() => {
       tv5 = Fp2.mul(tv4, tv1);
       tv3 = Fp2.cmov(tv2, tv3, isQR);
       tv4 = Fp2.cmov(tv5, tv4, isQR);
-      for (let i = c1; i > _1n9; i--) {
-        let tv52 = i - _2n7;
-        tv52 = _2n7 << tv52 - _1n9;
+      for (let i = c1; i > _1n10; i--) {
+        let tv52 = i - _2n8;
+        tv52 = _2n8 << tv52 - _1n10;
         let tvv5 = Fp2.pow(tv4, tv52);
         const e1 = Fp2.eql(tvv5, Fp2.ONE);
         tv2 = Fp2.mul(tv3, tv1);
@@ -19561,7 +19900,7 @@ var starknet = (() => {
 
   // src/utils/hash/transactionHash/v2.ts
   function computeHashOnElements2(data) {
-    return [...data, data.length].reduce((x, y) => esm_exports.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
+    return [...data, data.length].reduce((x, y) => esm_exports2.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
   }
   function calculateTransactionHashCommon(txHashPrefix, version, contractAddress, entryPointSelector, calldata, maxFee, chainId, additionalData = []) {
     const calldataHash = computeHashOnElements2(calldata);
@@ -19704,7 +20043,7 @@ var starknet = (() => {
 
   // src/utils/hash/transactionHash/index.ts
   function isV3InvokeTx(args) {
-    return ["0x3" /* V3 */, "0x100000000000000000000000000000003" /* F3 */].includes(
+    return [ETransactionVersion4.V3, ETransactionVersion4.F3].includes(
       args.version
     );
   }
@@ -19734,7 +20073,7 @@ var starknet = (() => {
     );
   }
   function isV3DeclareTx(args) {
-    return ["0x3" /* V3 */, "0x100000000000000000000000000000003" /* F3 */].includes(
+    return [ETransactionVersion4.V3, ETransactionVersion4.F3].includes(
       args.version
     );
   }
@@ -19766,7 +20105,7 @@ var starknet = (() => {
     );
   }
   function isV3DeployAccountTx(args) {
-    return ["0x3" /* V3 */, "0x100000000000000000000000000000003" /* F3 */].includes(
+    return [ETransactionVersion4.V3, ETransactionVersion4.F3].includes(
       args.version
     );
   }
@@ -20363,13 +20702,13 @@ var starknet = (() => {
 
   // src/utils/hash/classHash.ts
   function computePedersenHash(a, b) {
-    return esm_exports.pedersen(BigInt(a), BigInt(b));
+    return esm_exports2.pedersen(BigInt(a), BigInt(b));
   }
   function computePoseidonHash(a, b) {
-    return toHex(esm_exports.poseidonHash(BigInt(a), BigInt(b)));
+    return toHex(esm_exports2.poseidonHash(BigInt(a), BigInt(b)));
   }
   function computeHashOnElements3(data) {
-    return [...data, data.length].reduce((x, y) => esm_exports.pedersen(BigInt(x), BigInt(y)), 0).toString();
+    return [...data, data.length].reduce((x, y) => esm_exports2.pedersen(BigInt(x), BigInt(y)), 0).toString();
   }
   var computePedersenHashOnElements = computeHashOnElements3;
   function computePoseidonHashOnElements(data) {
@@ -20416,7 +20755,7 @@ var starknet = (() => {
     const { abi, program } = compiledContract;
     const contractClass = { abi, program };
     const serializedJson = formatSpaces(stringify2(contractClass, nullSkipReplacer));
-    return addHexPrefix(esm_exports.keccak(utf8ToArray(serializedJson)).toString(16));
+    return addHexPrefix(esm_exports2.keccak(utf8ToArray(serializedJson)).toString(16));
   }
   function computeLegacyContractClassHash(contract) {
     const compiledContract = isString(contract) ? parse2(contract) : contract;
@@ -20493,7 +20832,7 @@ var starknet = (() => {
   }
   function hashAbi(sierra) {
     const indentString = formatSpaces(stringify2(sierra.abi, null));
-    return BigInt(addHexPrefix(esm_exports.keccak(utf8ToArray(indentString)).toString(16)));
+    return BigInt(addHexPrefix(esm_exports2.keccak(utf8ToArray(indentString)).toString(16)));
   }
   function computeSierraContractClassHash(sierra) {
     const CONTRACT_CLASS_VERSION = "CONTRACT_CLASS_V0.1.0";
@@ -24763,10 +25102,10 @@ var starknet = (() => {
     };
   }
   function intDAM(dam) {
-    if (dam === "L1" /* L1 */)
-      return 0 /* L1 */;
-    if (dam === "L2" /* L2 */)
-      return 1 /* L2 */;
+    if (dam === EDataAvailabilityMode2.L1)
+      return EDAMode2.L1;
+    if (dam === EDataAvailabilityMode2.L2)
+      return EDAMode2.L2;
     throw Error("EDAM conversion");
   }
   function toTransactionVersion(defaultVersion, providedVersion) {
@@ -24784,14 +25123,14 @@ var starknet = (() => {
     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 === ETransactionVersion4.V0)
+      return ETransactionVersion4.F0;
+    if (version === ETransactionVersion4.V1)
+      return ETransactionVersion4.F1;
+    if (version === ETransactionVersion4.V2)
+      return ETransactionVersion4.F2;
+    if (version === ETransactionVersion4.V3)
+      return ETransactionVersion4.F3;
     throw Error(`toFeeVersion: ${version} is not supported`);
   }
   function v3Details(details) {
@@ -24799,16 +25138,16 @@ var starknet = (() => {
       tip: details.tip || 0,
       paymasterData: details.paymasterData || [],
       accountDeploymentData: details.accountDeploymentData || [],
-      nonceDataAvailabilityMode: details.nonceDataAvailabilityMode || "L1" /* L1 */,
-      feeDataAvailabilityMode: details.feeDataAvailabilityMode || "L1" /* L1 */,
+      nonceDataAvailabilityMode: details.nonceDataAvailabilityMode || EDataAvailabilityMode2.L1,
+      feeDataAvailabilityMode: details.feeDataAvailabilityMode || EDataAvailabilityMode2.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 === ETransactionVersion4.F2)
+      return ETransactionVersion4.F1;
+    if (providedVersion === ETransactionVersion4.V2)
+      return ETransactionVersion4.V1;
     return providedVersion;
   }
 
@@ -24848,102 +25187,13 @@ var starknet = (() => {
     validateAndParseEthAddress: () => validateAndParseEthAddress
   });
 
-  // node_modules/@noble/curves/node_modules/@noble/hashes/esm/_assert.js
-  function number2(n) {
-    if (!Number.isSafeInteger(n) || n < 0)
-      throw new Error(`positive integer expected, not ${n}`);
-  }
-  function isBytes6(a) {
-    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
-  }
-  function bytes2(b, ...lengths) {
-    if (!isBytes6(b))
-      throw new Error("Uint8Array expected");
-    if (lengths.length > 0 && !lengths.includes(b.length))
-      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
-  }
-  function hash2(h) {
-    if (typeof h !== "function" || typeof h.create !== "function")
-      throw new Error("Hash should be wrapped by utils.wrapConstructor");
-    number2(h.outputLen);
-    number2(h.blockLen);
-  }
-  function exists2(instance, checkFinished = true) {
-    if (instance.destroyed)
-      throw new Error("Hash instance has been destroyed");
-    if (checkFinished && instance.finished)
-      throw new Error("Hash#digest() has already been called");
-  }
-  function output2(out, instance) {
-    bytes2(out);
-    const min = instance.outputLen;
-    if (out.length < min) {
-      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
-    }
-  }
-
-  // node_modules/@noble/curves/node_modules/@noble/hashes/esm/crypto.js
-  var crypto2 = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
-
-  // node_modules/@noble/curves/node_modules/@noble/hashes/esm/utils.js
-  var createView2 = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-  var rotr2 = (word, shift) => word << 32 - shift | word >>> shift;
-  var isLE2 = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-  function utf8ToBytes4(str) {
-    if (typeof str !== "string")
-      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
-    return new Uint8Array(new TextEncoder().encode(str));
-  }
-  function toBytes2(data) {
-    if (typeof data === "string")
-      data = utf8ToBytes4(data);
-    bytes2(data);
-    return data;
-  }
-  function concatBytes4(...arrays) {
-    let sum = 0;
-    for (let i = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      bytes2(a);
-      sum += a.length;
-    }
-    const res = new Uint8Array(sum);
-    for (let i = 0, pad = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      res.set(a, pad);
-      pad += a.length;
-    }
-    return res;
-  }
-  var Hash2 = class {
-    // Safe version that clones internal state
-    clone() {
-      return this._cloneInto();
-    }
-  };
-  var toStr2 = {}.toString;
-  function wrapConstructor2(hashCons) {
-    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
-    const tmp = hashCons();
-    hashC.outputLen = tmp.outputLen;
-    hashC.blockLen = tmp.blockLen;
-    hashC.create = () => hashCons();
-    return hashC;
-  }
-  function randomBytes2(bytesLength = 32) {
-    if (crypto2 && typeof crypto2.getRandomValues === "function") {
-      return crypto2.getRandomValues(new Uint8Array(bytesLength));
-    }
-    throw new Error("crypto.getRandomValues must be defined");
-  }
-
-  // node_modules/@noble/curves/node_modules/@noble/hashes/esm/_md.js
+  // node_modules/@noble/hashes/esm/_md.js
   function setBigUint642(view, byteOffset, value, isLE3) {
     if (typeof view.setBigUint64 === "function")
       return view.setBigUint64(byteOffset, value, isLE3);
-    const _32n2 = BigInt(32);
+    const _32n3 = BigInt(32);
     const _u32_max = BigInt(4294967295);
-    const wh = Number(value >> _32n2 & _u32_max);
+    const wh = Number(value >> _32n3 & _u32_max);
     const wl = Number(value & _u32_max);
     const h = isLE3 ? 4 : 0;
     const l = isLE3 ? 0 : 4;
@@ -24952,7 +25202,7 @@ var starknet = (() => {
   }
   var Chi2 = (a, b, c) => a & b ^ ~a & c;
   var Maj2 = (a, b, c) => a & b ^ a & c ^ b & c;
-  var HashMD = class extends Hash2 {
+  var HashMD = class extends Hash {
     constructor(blockLen, outputLen, padOffset, isLE3) {
       super();
       this.blockLen = blockLen;
@@ -24964,17 +25214,17 @@ var starknet = (() => {
       this.pos = 0;
       this.destroyed = false;
       this.buffer = new Uint8Array(blockLen);
-      this.view = createView2(this.buffer);
+      this.view = createView(this.buffer);
     }
     update(data) {
-      exists2(this);
+      exists(this);
       const { view, buffer, blockLen } = this;
-      data = toBytes2(data);
+      data = toBytes(data);
       const len = data.length;
       for (let pos = 0; pos < len; ) {
         const take = Math.min(blockLen - this.pos, len - pos);
         if (take === blockLen) {
-          const dataView = createView2(data);
+          const dataView = createView(data);
           for (; blockLen <= len - pos; pos += blockLen)
             this.process(dataView, pos);
           continue;
@@ -24992,8 +25242,8 @@ var starknet = (() => {
       return this;
     }
     digestInto(out) {
-      exists2(this);
-      output2(out, this);
+      exists(this);
+      output(out, this);
       this.finished = true;
       const { buffer, view, blockLen, isLE: isLE3 } = this;
       let { pos } = this;
@@ -25007,7 +25257,7 @@ var starknet = (() => {
         buffer[i] = 0;
       setBigUint642(view, blockLen - 8, BigInt(this.length * 8), isLE3);
       this.process(view, 0);
-      const oview = createView2(out);
+      const oview = createView(out);
       const len = this.outputLen;
       if (len % 4)
         throw new Error("_sha2: outputLen should be aligned to 32bit");
@@ -25039,7 +25289,7 @@ var starknet = (() => {
     }
   };
 
-  // node_modules/@noble/curves/node_modules/@noble/hashes/esm/sha256.js
+  // node_modules/@noble/hashes/esm/sha256.js
   var SHA256_K2 = /* @__PURE__ */ new Uint32Array([
     1116352408,
     1899447441,
@@ -25150,15 +25400,15 @@ var starknet = (() => {
       for (let i = 16; i < 64; i++) {
         const W15 = SHA256_W2[i - 15];
         const W2 = SHA256_W2[i - 2];
-        const s0 = rotr2(W15, 7) ^ rotr2(W15, 18) ^ W15 >>> 3;
-        const s1 = rotr2(W2, 17) ^ rotr2(W2, 19) ^ W2 >>> 10;
+        const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+        const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
         SHA256_W2[i] = s1 + SHA256_W2[i - 7] + s0 + SHA256_W2[i - 16] | 0;
       }
       let { A, B, C, D, E, F, G, H } = this;
       for (let i = 0; i < 64; i++) {
-        const sigma1 = rotr2(E, 6) ^ rotr2(E, 11) ^ rotr2(E, 25);
+        const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
         const T1 = H + sigma1 + Chi2(E, F, G) + SHA256_K2[i] + SHA256_W2[i] | 0;
-        const sigma0 = rotr2(A, 2) ^ rotr2(A, 13) ^ rotr2(A, 22);
+        const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
         const T2 = sigma0 + Maj2(A, B, C) | 0;
         H = G;
         G = F;
@@ -25187,16 +25437,16 @@ var starknet = (() => {
       this.buffer.fill(0);
     }
   };
-  var sha2562 = /* @__PURE__ */ wrapConstructor2(() => new SHA2562());
+  var sha2562 = /* @__PURE__ */ wrapConstructor(() => new SHA2562());
 
-  // node_modules/@noble/curves/node_modules/@noble/hashes/esm/hmac.js
-  var HMAC2 = class extends Hash2 {
+  // node_modules/@noble/hashes/esm/hmac.js
+  var HMAC2 = class extends Hash {
     constructor(hash3, _key) {
       super();
       this.finished = false;
       this.destroyed = false;
-      hash2(hash3);
-      const key = toBytes2(_key);
+      hash(hash3);
+      const key = toBytes(_key);
       this.iHash = hash3.create();
       if (typeof this.iHash.update !== "function")
         throw new Error("Expected instance of class which extends utils.Hash");
@@ -25215,13 +25465,13 @@ var starknet = (() => {
       pad.fill(0);
     }
     update(buf) {
-      exists2(this);
+      exists(this);
       this.iHash.update(buf);
       return this;
     }
     digestInto(out) {
-      exists2(this);
-      bytes2(out, this.outputLen);
+      exists(this);
+      bytes(out, this.outputLen);
       this.finished = true;
       this.iHash.digestInto(out);
       this.oHash.update(out);
@@ -25258,8 +25508,8 @@ var starknet = (() => {
   function getHash2(hash3) {
     return {
       hash: hash3,
-      hmac: (key, ...msgs) => hmac2(hash3, key, concatBytes4(...msgs)),
-      randomBytes: randomBytes2
+      hmac: (key, ...msgs) => hmac2(hash3, key, concatBytes2(...msgs)),
+      randomBytes
     };
   }
   function createCurve(curveDef, defHash) {
@@ -25270,9 +25520,9 @@ var starknet = (() => {
   // node_modules/@noble/curves/esm/secp256k1.js
   var secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
   var secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
-  var _1n10 = BigInt(1);
-  var _2n8 = BigInt(2);
-  var divNearest = (a, b) => (a + b / _2n8) / b;
+  var _1n11 = BigInt(1);
+  var _2n9 = BigInt(2);
+  var divNearest = (a, b) => (a + b / _2n9) / b;
   function sqrtMod(y) {
     const P = secp256k1P;
     const _3n5 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
@@ -25281,7 +25531,7 @@ var starknet = (() => {
     const b3 = b2 * b2 * y % P;
     const b6 = pow22(b3, _3n5, P) * b3 % P;
     const b9 = pow22(b6, _3n5, P) * b3 % P;
-    const b11 = pow22(b9, _2n8, P) * b2 % P;
+    const b11 = pow22(b9, _2n9, P) * b2 % P;
     const b22 = pow22(b11, _11n, P) * b11 % P;
     const b44 = pow22(b22, _22n, P) * b22 % P;
     const b88 = pow22(b44, _44n, P) * b44 % P;
@@ -25290,7 +25540,7 @@ var starknet = (() => {
     const b223 = pow22(b220, _3n5, P) * b3 % P;
     const t1 = pow22(b223, _23n, P) * b22 % P;
     const t2 = pow22(t1, _6n, P) * b2 % P;
-    const root = pow22(t2, _2n8, P);
+    const root = pow22(t2, _2n9, P);
     if (!Fp.eql(Fp.sqr(root), y))
       throw new Error("Cannot find square root");
     return root;
@@ -25323,7 +25573,7 @@ var starknet = (() => {
       splitScalar: (k) => {
         const n = secp256k1N;
         const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
-        const b1 = -_1n10 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
+        const b1 = -_1n11 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
         const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
         const b2 = a1;
         const POW_2_128 = BigInt("0x100000000000000000000000000000000");
@@ -25344,7 +25594,7 @@ var starknet = (() => {
       }
     }
   }, sha2562);
-  var _0n10 = BigInt(0);
+  var _0n11 = BigInt(0);
   var Point = secp256k1.ProjectivePoint;
 
   // src/utils/eth.ts
@@ -25354,7 +25604,7 @@ var starknet = (() => {
   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;
   }
 
@@ -25565,9 +25815,10 @@ var starknet = (() => {
     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];
   };
@@ -25590,10 +25841,14 @@ var starknet = (() => {
     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);
@@ -25602,6 +25857,9 @@ var starknet = (() => {
       } 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);
@@ -25631,15 +25889,10 @@ var starknet = (() => {
     }
     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) : ETransactionVersion4.V3;
+    return version === ETransactionVersion4.V3 || version === ETransactionVersion4.F3;
   }
   function isVersion(version, response) {
     const [majorS, minorS] = version.split(".");
@@ -25740,7 +25993,7 @@ var starknet = (() => {
           ]
         },
         address: calculateContractAddressFromHash(
-          unique2 ? esm_exports.pedersen(address, deploySalt) : deploySalt,
+          unique2 ? esm_exports2.pedersen(address, deploySalt) : deploySalt,
           classHash,
           compiledConstructorCallData,
           unique2 ? UDC.ADDRESS : 0
@@ -25754,10 +26007,10 @@ var starknet = (() => {
   }
   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: ETransactionVersion4.F1,
+      v2: ETransactionVersion4.F2,
+      v3: ETransactionVersion4.F3
+    } : { v1: ETransactionVersion4.V1, v2: ETransactionVersion4.V2, v3: ETransactionVersion4.V3 };
   }
 
   // src/channel/rpc_0_6.ts
@@ -25918,11 +26171,12 @@ var starknet = (() => {
      * - 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)
@@ -26245,7 +26499,6 @@ var starknet = (() => {
         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),
@@ -26308,10 +26561,20 @@ var starknet = (() => {
     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) {
@@ -26326,6 +26589,10 @@ var starknet = (() => {
       this.specVersion = specVersion;
       this.waitMode = waitMode || false;
       this.requestId = 0;
+      this.transactionRetryIntervalFallback = transactionRetryIntervalFallback;
+    }
+    get transactionRetryIntervalDefault() {
+      return this.transactionRetryIntervalFallback ?? 5e3;
     }
     setChainId(chainId) {
       this.chainId = chainId;
@@ -26456,17 +26723,18 @@ var starknet = (() => {
      * - 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(esm_exports.ESimulationFlag.SKIP_VALIDATE);
       if (skipFeeCharge)
-        simulationFlags.push(rpcspec_0_7_exports.ESimulationFlag.SKIP_FEE_CHARGE);
+        simulationFlags.push(esm_exports.ESimulationFlag.SKIP_FEE_CHARGE);
       return this.fetchEndpoint("starknet_simulateTransactions", {
         block_id,
         transactions: invocations.map((it) => this.buildTransaction(it)),
@@ -26478,17 +26746,17 @@ var starknet = (() => {
       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
+        esm_exports.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
+        esm_exports.ETransactionExecutionStatus.SUCCEEDED,
+        esm_exports.ETransactionStatus.ACCEPTED_ON_L2,
+        esm_exports.ETransactionStatus.ACCEPTED_ON_L1
       ];
       let txStatus;
       while (!onchain) {
@@ -26573,7 +26841,7 @@ var starknet = (() => {
       let flags = {};
       if (!isVersion("0.5", await this.getSpecVersion())) {
         flags = {
-          simulation_flags: skipValidate ? [rpcspec_0_7_exports.ESimulationFlag.SKIP_VALIDATE] : []
+          simulation_flags: skipValidate ? [esm_exports.ESimulationFlag.SKIP_VALIDATE] : []
         };
       }
       return this.fetchEndpoint("starknet_estimateFee", {
@@ -26589,9 +26857,9 @@ var starknet = (() => {
           invoke_transaction: {
             sender_address: functionInvocation.contractAddress,
             calldata: CallData.toHex(functionInvocation.calldata),
-            type: rpcspec_0_7_exports.ETransactionType.INVOKE,
+            type: esm_exports.ETransactionType.INVOKE,
             max_fee: toHex(details.maxFee || 0),
-            version: rpcspec_0_7_exports.ETransactionVersion.V1,
+            version: esm_exports.ETransactionVersion.V1,
             signature: signatureToHexArray(functionInvocation.signature),
             nonce: toHex(details.nonce)
           }
@@ -26599,10 +26867,10 @@ var starknet = (() => {
       } else {
         promise = this.fetchEndpoint("starknet_addInvokeTransaction", {
           invoke_transaction: {
-            type: rpcspec_0_7_exports.ETransactionType.INVOKE,
+            type: esm_exports.ETransactionType.INVOKE,
             sender_address: functionInvocation.contractAddress,
             calldata: CallData.toHex(functionInvocation.calldata),
-            version: rpcspec_0_7_exports.ETransactionVersion.V3,
+            version: esm_exports.ETransactionVersion.V3,
             signature: signatureToHexArray(functionInvocation.signature),
             nonce: toHex(details.nonce),
             resource_bounds: details.resourceBounds,
@@ -26621,13 +26889,13 @@ var starknet = (() => {
       if (!isSierra(contract) && !isV3Tx(details)) {
         promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
           declare_transaction: {
-            type: rpcspec_0_7_exports.ETransactionType.DECLARE,
+            type: esm_exports.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: esm_exports.ETransactionVersion.V1,
             max_fee: toHex(details.maxFee || 0),
             signature: signatureToHexArray(signature),
             sender_address: senderAddress,
@@ -26637,7 +26905,7 @@ var starknet = (() => {
       } else if (isSierra(contract) && !isV3Tx(details)) {
         promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
           declare_transaction: {
-            type: rpcspec_0_7_exports.ETransactionType.DECLARE,
+            type: esm_exports.ETransactionType.DECLARE,
             contract_class: {
               sierra_program: decompressProgram(contract.sierra_program),
               contract_class_version: contract.contract_class_version,
@@ -26645,7 +26913,7 @@ var starknet = (() => {
               abi: contract.abi
             },
             compiled_class_hash: compiledClassHash || "",
-            version: rpcspec_0_7_exports.ETransactionVersion.V2,
+            version: esm_exports.ETransactionVersion.V2,
             max_fee: toHex(details.maxFee || 0),
             signature: signatureToHexArray(signature),
             sender_address: senderAddress,
@@ -26655,10 +26923,10 @@ var starknet = (() => {
       } else if (isSierra(contract) && isV3Tx(details)) {
         promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
           declare_transaction: {
-            type: rpcspec_0_7_exports.ETransactionType.DECLARE,
+            type: esm_exports.ETransactionType.DECLARE,
             sender_address: senderAddress,
             compiled_class_hash: compiledClassHash || "",
-            version: rpcspec_0_7_exports.ETransactionVersion.V3,
+            version: esm_exports.ETransactionVersion.V3,
             signature: signatureToHexArray(signature),
             nonce: toHex(details.nonce),
             contract_class: {
@@ -26688,9 +26956,9 @@ var starknet = (() => {
             constructor_calldata: CallData.toHex(constructorCalldata || []),
             class_hash: toHex(classHash),
             contract_address_salt: toHex(addressSalt || 0),
-            type: rpcspec_0_7_exports.ETransactionType.DEPLOY_ACCOUNT,
+            type: esm_exports.ETransactionType.DEPLOY_ACCOUNT,
             max_fee: toHex(details.maxFee || 0),
-            version: rpcspec_0_7_exports.ETransactionVersion.V1,
+            version: esm_exports.ETransactionVersion.V1,
             signature: signatureToHexArray(signature),
             nonce: toHex(details.nonce)
           }
@@ -26698,8 +26966,8 @@ var starknet = (() => {
       } 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: esm_exports.ETransactionType.DEPLOY_ACCOUNT,
+            version: esm_exports.ETransactionVersion.V3,
             signature: signatureToHexArray(signature),
             nonce: toHex(details.nonce),
             contract_address_salt: toHex(addressSalt || 0),
@@ -26782,8 +27050,7 @@ var starknet = (() => {
       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: esm_exports.ETransactionType.INVOKE,
           sender_address: invocation.contractAddress,
           calldata: CallData.toHex(invocation.calldata),
           version: toHex(invocation.version || defaultVersions.v3),
@@ -26899,6 +27166,9 @@ var starknet = (() => {
         abi: isString(res.abi) ? JSON.parse(res.abi) : res.abi
       };
     }
+    parseL1GasPriceResponse(res) {
+      return res.l1_gas_price.price_in_wei;
+    }
   };
 
   // src/utils/transactionReceipt.ts
@@ -26997,6 +27267,63 @@ var starknet = (() => {
     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(bytesToHex(keccak_256(hexToBytes2(myEncode))));
+    }
     async getBlockWithReceipts(blockIdentifier) {
       if (this.channel instanceof rpc_0_6_exports.RpcChannel)
         throw new LibraryError("Unsupported method for RPC version");
@@ -27048,7 +27375,7 @@ var starknet = (() => {
     }
     /**
      * @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/>
@@ -27510,7 +27837,6 @@ var starknet = (() => {
   }
   var StarknetIdContract = /* @__PURE__ */ ((StarknetIdContract2) => {
     StarknetIdContract2["MAINNET"] = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678";
-    StarknetIdContract2["TESTNET"] = "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce";
     StarknetIdContract2["TESTNET_SEPOLIA"] = "0x0707f09bc576bd7cfee59694846291047e965f4184fe13dac62c56759b3b6fa7";
     return StarknetIdContract2;
   })(StarknetIdContract || {});
@@ -27518,8 +27844,6 @@ var starknet = (() => {
     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:
@@ -27528,7 +27852,6 @@ var starknet = (() => {
   }
   var StarknetIdIdentityContract = /* @__PURE__ */ ((StarknetIdIdentityContract2) => {
     StarknetIdIdentityContract2["MAINNET"] = "0x05dbdedc203e92749e2e746e2d40a768d966bd243df04a6b712e222bc040a9af";
-    StarknetIdIdentityContract2["TESTNET"] = "0x783a9097b26eae0586373b2ce0ed3529ddc44069d1e0fbc4f66d42b69d6850d";
     StarknetIdIdentityContract2["TESTNET_SEPOLIA"] = "0x070DF8B4F5cb2879f8592849fA8f3134da39d25326B8558cc9C8FE8D47EA3A90";
     return StarknetIdIdentityContract2;
   })(StarknetIdIdentityContract || {});
@@ -27536,8 +27859,6 @@ var starknet = (() => {
     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:
@@ -27549,8 +27870,6 @@ var starknet = (() => {
     switch (chainId) {
       case "0x534e5f4d41494e" /* SN_MAIN */:
         return StarknetIdMulticallContract;
-      case "0x534e5f474f45524c49" /* SN_GOERLI */:
-        return StarknetIdMulticallContract;
       case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
         return StarknetIdMulticallContract;
       default:
@@ -27559,7 +27878,6 @@ var starknet = (() => {
   }
   var StarknetIdVerifierContract = /* @__PURE__ */ ((StarknetIdVerifierContract2) => {
     StarknetIdVerifierContract2["MAINNET"] = "0x07d14dfd8ee95b41fce179170d88ba1f0d5a512e13aeb232f19cfeec0a88f8bf";
-    StarknetIdVerifierContract2["TESTNET"] = "0x057c942544063c3aea6ea6c37009cc9d1beacd750cb6801549a129c7265f0f11";
     StarknetIdVerifierContract2["TESTNET_SEPOLIA"] = "0x0182EcE8173C216A395f4828e1523541b7e3600bf190CB252E1a1A0cE219d184";
     return StarknetIdVerifierContract2;
   })(StarknetIdVerifierContract || {});
@@ -27567,8 +27885,6 @@ var starknet = (() => {
     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:
@@ -27577,7 +27893,6 @@ var starknet = (() => {
   }
   var StarknetIdPfpContract = /* @__PURE__ */ ((StarknetIdPfpContract2) => {
     StarknetIdPfpContract2["MAINNET"] = "0x070aaa20ec4a46da57c932d9fd89ca5e6bb9ca3188d3df361a32306aff7d59c7";
-    StarknetIdPfpContract2["TESTNET"] = "0x03cac3228b434259734ee0e4ff445f642206ea11adace7e4f45edd2596748698";
     StarknetIdPfpContract2["TESTNET_SEPOLIA"] = "0x058061bb6bdc501eE215172c9f87d557C1E0f466dC498cA81b18f998Bf1362b2";
     return StarknetIdPfpContract2;
   })(StarknetIdPfpContract || {});
@@ -27585,8 +27900,6 @@ var starknet = (() => {
     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:
@@ -27597,7 +27910,6 @@ var starknet = (() => {
   }
   var StarknetIdPopContract = /* @__PURE__ */ ((StarknetIdPopContract2) => {
     StarknetIdPopContract2["MAINNET"] = "0x0293eb2ba9862f762bd3036586d5755a782bd22e6f5028320f1d0405fd47bff4";
-    StarknetIdPopContract2["TESTNET"] = "0x03528caf090179e337931ee669a5b0214041e1bae30d460ff07d2cea2c7a9106";
     StarknetIdPopContract2["TESTNET_SEPOLIA"] = "0x0023FE3b845ed5665a9eb3792bbB17347B490EE4090f855C1298d03BB5F49B49";
     return StarknetIdPopContract2;
   })(StarknetIdPopContract || {});
@@ -27605,8 +27917,6 @@ var starknet = (() => {
     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:
@@ -27671,13 +27981,7 @@ var starknet = (() => {
       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) {
@@ -27691,6 +27995,26 @@ 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);
@@ -27715,100 +28039,111 @@ var starknet = (() => {
       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 = [];
@@ -27848,6 +28183,25 @@ 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
@@ -28236,11 +28590,11 @@ var starknet = (() => {
   // src/signer/default.ts
   var Signer = class {
     pk;
-    constructor(pk = esm_exports.utils.randomPrivateKey()) {
+    constructor(pk = esm_exports2.utils.randomPrivateKey()) {
       this.pk = pk instanceof Uint8Array ? buf2hex(pk) : toHex(pk);
     }
     async getPubKey() {
-      return esm_exports.getStarkKey(this.pk);
+      return esm_exports2.getStarkKey(this.pk);
     }
     async signMessage(typedData, accountAddress) {
       const msgHash = getMessageHash(typedData, accountAddress);
@@ -28320,7 +28674,7 @@ var starknet = (() => {
       return this.signRaw(msgHash);
     }
     async signRaw(msgHash) {
-      return esm_exports.sign(msgHash, this.pk);
+      return esm_exports2.sign(msgHash, this.pk);
     }
   };
 
@@ -28499,7 +28853,7 @@ var starknet = (() => {
     address;
     cairoVersion;
     transactionVersion;
-    constructor(providerOrOptions, address, pkOrSigner, cairoVersion, transactionVersion = "0x2" /* V2 */) {
+    constructor(providerOrOptions, address, pkOrSigner, cairoVersion, transactionVersion = ETransactionVersion4.V2) {
       super(providerOrOptions);
       this.address = address.toLowerCase();
       this.signer = isString(pkOrSigner) || pkOrSigner instanceof Uint8Array ? new Signer(pkOrSigner) : pkOrSigner;
@@ -28510,11 +28864,11 @@ var starknet = (() => {
     }
     // provided version or contract based preferred transactionVersion
     getPreferredVersion(type12, type3) {
-      if (this.transactionVersion === "0x3" /* V3 */)
+      if (this.transactionVersion === ETransactionVersion4.V3)
         return type3;
-      if (this.transactionVersion === "0x2" /* V2 */)
+      if (this.transactionVersion === ETransactionVersion4.V2)
         return type12;
-      return "0x3" /* V3 */;
+      return ETransactionVersion4.V3;
     }
     async getNonce(blockIdentifier) {
       return super.getNonceForAddress(this.address, blockIdentifier);
@@ -28527,7 +28881,7 @@ var starknet = (() => {
       }
     }
     /**
-     * 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) {
@@ -28550,7 +28904,7 @@ var starknet = (() => {
       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(ETransactionVersion4.F1, ETransactionVersion4.F3),
         toFeeVersion(providedVersion)
       );
       const chainId = await this.getChainId();
@@ -28581,7 +28935,7 @@ var starknet = (() => {
       } = 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) ? ETransactionVersion4.F1 : this.getPreferredVersion(ETransactionVersion4.F2, ETransactionVersion4.F3),
         toFeeVersion(providedVersion)
       );
       const chainId = await this.getChainId();
@@ -28611,7 +28965,7 @@ var starknet = (() => {
     }, details = {}) {
       const { blockIdentifier, version: providedVersion, skipValidate = true } = details;
       const version = toTransactionVersion(
-        this.getPreferredVersion("0x100000000000000000000000000000001" /* F1 */, "0x100000000000000000000000000000003" /* F3 */),
+        this.getPreferredVersion(ETransactionVersion4.F1, ETransactionVersion4.F3),
         toFeeVersion(providedVersion)
       );
       const nonce = ZERO;
@@ -28647,10 +29001,10 @@ var starknet = (() => {
       const accountInvocations = await this.accountInvocationsFactory(invocations, {
         ...v3Details(details),
         versions: [
-          "0x100000000000000000000000000000001" /* F1 */,
+          ETransactionVersion4.F1,
           // non-sierra
           toTransactionVersion(
-            this.getPreferredVersion("0x100000000000000000000000000000002" /* F2 */, "0x100000000000000000000000000000003" /* F3 */),
+            this.getPreferredVersion(ETransactionVersion4.F2, ETransactionVersion4.F3),
             version
           )
           // sierra
@@ -28669,10 +29023,10 @@ var starknet = (() => {
       const accountInvocations = await this.accountInvocationsFactory(invocations, {
         ...v3Details(details),
         versions: [
-          "0x1" /* V1 */,
+          ETransactionVersion4.V1,
           // non-sierra
           toTransactionVersion(
-            this.getPreferredVersion("0x2" /* V2 */, "0x3" /* V3 */),
+            this.getPreferredVersion(ETransactionVersion4.V2, ETransactionVersion4.V3),
             version
           )
         ],
@@ -28691,7 +29045,7 @@ var starknet = (() => {
       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(ETransactionVersion4.V1, ETransactionVersion4.V3),
         // TODO: does this depend on cairo version ?
         details.version
       );
@@ -28749,7 +29103,7 @@ var starknet = (() => {
       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) ? ETransactionVersion4.V1 : this.getPreferredVersion(ETransactionVersion4.V2, ETransactionVersion4.V3),
         providedVersion
       );
       const estimate = await this.getUniversalSuggestedFee(
@@ -28813,7 +29167,7 @@ var starknet = (() => {
       contractAddress: providedContractAddress
     }, details = {}) {
       const version = toTransactionVersion(
-        this.getPreferredVersion("0x1" /* V1 */, "0x3" /* V3 */),
+        this.getPreferredVersion(ETransactionVersion4.V1, ETransactionVersion4.V3),
         details.version
       );
       const nonce = ZERO;
@@ -28862,32 +29216,64 @@ var starknet = (() => {
     async hashMessage(typedData) {
       return getMessageHash(typedData, this.address);
     }
-    async verifyMessageHash(hash3, signature) {
-      try {
-        const resp = await this.callContract({
-          contractAddress: this.address,
-          entrypoint: "isValidSignature",
-          calldata: CallData.compile({
-            hash: toBigInt(hash3).toString(),
-            signature: formatSignature(signature)
-          })
-        });
-        if (BigInt(resp[0]) === 0n) {
-          return false;
-        }
-        return true;
-      } catch (err2) {
-        if (["argent/invalid-signature", "is invalid, with respect to the public key"].some(
-          (errMessage) => err2.message.includes(errMessage)
-        )) {
-          return false;
+    async verifyMessageHash(hash3, 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 error2;
+      for (const SigVerificationFName of knownSigVerificationFName) {
+        try {
+          const resp = await this.callContract({
+            contractAddress: this.address,
+            entrypoint: SigVerificationFName,
+            calldata: CallData.compile({
+              hash: toBigInt(hash3).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 (err2) {
+          if (knownSignatureResponse.error.some(
+            (errMessage) => err2.message.includes(errMessage)
+          )) {
+            return false;
+          }
+          error2 = err2;
         }
-        throw Error(`Signature verification request is rejected by the network: ${err2}`);
       }
+      throw Error(`Signature verification Error: ${error2}`);
     }
-    async verifyMessage(typedData, signature) {
+    async verifyMessage(typedData, signature, signatureVerificationFunctionName, signatureVerificationResponse) {
       const hash3 = await this.hashMessage(typedData);
-      return this.verifyMessageHash(hash3, signature);
+      return this.verifyMessageHash(
+        hash3,
+        signature,
+        signatureVerificationFunctionName,
+        signatureVerificationResponse
+      );
     }
     /*
      * Support methods
@@ -28895,7 +29281,7 @@ var starknet = (() => {
     async getUniversalSuggestedFee(version, { type, payload }, details) {
       let maxFee = 0;
       let resourceBounds = estimateFeeToBounds(ZERO);
-      if (version === "0x3" /* V3 */) {
+      if (version === ETransactionVersion4.V3) {
         resourceBounds = details.resourceBounds ?? (await this.getSuggestedFee({ type, payload }, details)).resourceBounds;
       } else {
         maxFee = details.maxFee ?? (await this.getSuggestedFee({ type, payload }, details)).suggestedMaxFee;
@@ -28948,7 +29334,7 @@ var starknet = (() => {
     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 === ETransactionVersion32.F3 || details.version === ETransactionVersion32.V3)) {
         throw Error("V3 Transaction work with Cairo1 Contracts and require compiledClassHash");
       }
       const signature = !details.skipValidate ? await this.signer.signDeclareTransaction({
@@ -29101,7 +29487,6 @@ var starknet = (() => {
   var connect_exports = {};
   __export(connect_exports, {
     addDeclareTransaction: () => addDeclareTransaction,
-    addDeployAccountTransaction: () => addDeployAccountTransaction,
     addInvokeTransaction: () => addInvokeTransaction,
     addStarknetChain: () => addStarknetChain,
     deploymentData: () => deploymentData,
@@ -29115,11 +29500,11 @@ var starknet = (() => {
     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
       }
     });
   }
@@ -29154,30 +29539,24 @@ var starknet = (() => {
   }
   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);
@@ -29206,7 +29585,7 @@ var starknet = (() => {
       walletProvider.request({
         type: "wallet_requestAccounts",
         params: {
-          silentMode: false
+          silent_mode: false
         }
       }).then((res) => {
         this.address = res[0].toLowerCase();
@@ -29247,7 +29626,7 @@ var starknet = (() => {
         const { contractAddress, entrypoint, calldata } = it;
         return {
           contract_address: contractAddress,
-          entrypoint,
+          entry_point: entrypoint,
           calldata
         };
       });
@@ -29280,14 +29659,6 @@ var starknet = (() => {
         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);
     }
@@ -29307,7 +29678,7 @@ var starknet = (() => {
       abiEntryMod.name = entryName;
       return {
         ...acc,
-        [addHexPrefix(esm_exports.keccak(utf8ToArray(entryName)).toString(16))]: abiEntryMod
+        [addHexPrefix(esm_exports2.keccak(utf8ToArray(entryName)).toString(16))]: abiEntryMod
       };
     }, {});
   }
@@ -29951,6 +30322,9 @@ tough-cookie/lib/cookie.js:
 @noble/hashes/esm/utils.js:
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
 @noble/curves/esm/abstract/utils.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
@@ -29984,9 +30358,6 @@ tough-cookie/lib/cookie.js:
 pako/dist/pako.esm.mjs:
   (*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) *)
 
-@noble/hashes/esm/utils.js:
-  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
 @noble/curves/esm/_shortw_utils.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)