starknet 6.7.0 → 6.8.0

package/dist/index.js

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -67,7 +68,7 @@ __export(src_exports, {
   TransactionFinalityStatus: () => TransactionFinalityStatus,
   TransactionStatus: () => TransactionStatus,
   TransactionType: () => TransactionType,
-  TypedDataRevision: () => import_starknet_types.TypedDataRevision,
+  TypedDataRevision: () => import_starknet_types_07.TypedDataRevision,
   UINT_128_MAX: () => UINT_128_MAX,
   UINT_128_MIN: () => UINT_128_MIN,
   UINT_256_HIGH_MAX: () => UINT_256_HIGH_MAX,
@@ -104,6 +105,7 @@ __export(src_exports, {
   merkle: () => merkle_exports,
   num: () => num_exports,
   number: () => number,
+  parseCalldataField: () => parseCalldataField,
   parseUDCEvent: () => parseUDCEvent,
   provider: () => provider_exports,
   selector: () => selector_exports,
@@ -141,7 +143,7 @@ __export(constants_exports, {
   RPC_NODES: () => RPC_NODES,
   StarknetChainId: () => StarknetChainId,
   TEXT_TO_FELT_MAX_LEN: () => TEXT_TO_FELT_MAX_LEN,
-  TRANSACTION_VERSION: () => ETransactionVersion4,
+  TRANSACTION_VERSION: () => api_exports.ETransactionVersion,
   TransactionHashPrefix: () => TransactionHashPrefix,
   UDC: () => UDC,
   ZERO: () => ZERO,
@@ -151,22 +153,9 @@ __export(constants_exports, {
 // src/types/api/index.ts
 var api_exports = {};
 __export(api_exports, {
-  EBlockTag: () => EBlockTag2,
-  EDAMode: () => EDAMode2,
-  EDataAvailabilityMode: () => EDataAvailabilityMode2,
-  ESimulationFlag: () => ESimulationFlag2,
-  ETransactionExecutionStatus: () => ETransactionExecutionStatus2,
-  ETransactionFinalityStatus: () => ETransactionFinalityStatus2,
-  ETransactionStatus: () => ETransactionStatus2,
-  ETransactionType: () => ETransactionType2,
-  ETransactionVersion: () => ETransactionVersion4,
-  ETransactionVersion2: () => ETransactionVersion22,
-  ETransactionVersion3: () => ETransactionVersion32,
-  Errors: () => errors_exports2,
   JRPC: () => jsonrpc_exports,
   RPCSPEC06: () => rpcspec_0_6_exports,
-  RPCSPEC07: () => rpcspec_0_7_exports,
-  SPEC: () => components_exports2
+  RPCSPEC07: () => RPCSPEC07
 });
 
 // src/types/api/jsonrpc/index.ts
@@ -197,40 +186,40 @@ var errors_exports = {};
 var components_exports = {};
 
 // src/types/api/rpcspec_0_6/nonspec.ts
-var ETransactionType = /* @__PURE__ */ ((ETransactionType3) => {
-  ETransactionType3["DECLARE"] = "DECLARE";
-  ETransactionType3["DEPLOY"] = "DEPLOY";
-  ETransactionType3["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-  ETransactionType3["INVOKE"] = "INVOKE";
-  ETransactionType3["L1_HANDLER"] = "L1_HANDLER";
-  return ETransactionType3;
+var ETransactionType = /* @__PURE__ */ ((ETransactionType2) => {
+  ETransactionType2["DECLARE"] = "DECLARE";
+  ETransactionType2["DEPLOY"] = "DEPLOY";
+  ETransactionType2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
+  ETransactionType2["INVOKE"] = "INVOKE";
+  ETransactionType2["L1_HANDLER"] = "L1_HANDLER";
+  return ETransactionType2;
 })(ETransactionType || {});
-var ESimulationFlag = /* @__PURE__ */ ((ESimulationFlag3) => {
-  ESimulationFlag3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-  ESimulationFlag3["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
-  return ESimulationFlag3;
+var ESimulationFlag = /* @__PURE__ */ ((ESimulationFlag2) => {
+  ESimulationFlag2["SKIP_VALIDATE"] = "SKIP_VALIDATE";
+  ESimulationFlag2["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
+  return ESimulationFlag2;
 })(ESimulationFlag || {});
-var ETransactionStatus = /* @__PURE__ */ ((ETransactionStatus3) => {
-  ETransactionStatus3["RECEIVED"] = "RECEIVED";
-  ETransactionStatus3["REJECTED"] = "REJECTED";
-  ETransactionStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  ETransactionStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  return ETransactionStatus3;
+var ETransactionStatus = /* @__PURE__ */ ((ETransactionStatus2) => {
+  ETransactionStatus2["RECEIVED"] = "RECEIVED";
+  ETransactionStatus2["REJECTED"] = "REJECTED";
+  ETransactionStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+  ETransactionStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+  return ETransactionStatus2;
 })(ETransactionStatus || {});
-var ETransactionFinalityStatus = /* @__PURE__ */ ((ETransactionFinalityStatus3) => {
-  ETransactionFinalityStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  ETransactionFinalityStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  return ETransactionFinalityStatus3;
+var ETransactionFinalityStatus = /* @__PURE__ */ ((ETransactionFinalityStatus2) => {
+  ETransactionFinalityStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+  ETransactionFinalityStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+  return ETransactionFinalityStatus2;
 })(ETransactionFinalityStatus || {});
-var ETransactionExecutionStatus = /* @__PURE__ */ ((ETransactionExecutionStatus3) => {
-  ETransactionExecutionStatus3["SUCCEEDED"] = "SUCCEEDED";
-  ETransactionExecutionStatus3["REVERTED"] = "REVERTED";
-  return ETransactionExecutionStatus3;
+var ETransactionExecutionStatus = /* @__PURE__ */ ((ETransactionExecutionStatus2) => {
+  ETransactionExecutionStatus2["SUCCEEDED"] = "SUCCEEDED";
+  ETransactionExecutionStatus2["REVERTED"] = "REVERTED";
+  return ETransactionExecutionStatus2;
 })(ETransactionExecutionStatus || {});
-var EBlockTag = /* @__PURE__ */ ((EBlockTag3) => {
-  EBlockTag3["LATEST"] = "latest";
-  EBlockTag3["PENDING"] = "pending";
-  return EBlockTag3;
+var EBlockTag = /* @__PURE__ */ ((EBlockTag2) => {
+  EBlockTag2["LATEST"] = "latest";
+  EBlockTag2["PENDING"] = "pending";
+  return EBlockTag2;
 })(EBlockTag || {});
 var EDataAvailabilityMode = /* @__PURE__ */ ((EDataAvailabilityMode3) => {
   EDataAvailabilityMode3["L1"] = "L1";
@@ -242,127 +231,35 @@ var EDAMode = /* @__PURE__ */ ((EDAMode4) => {
   EDAMode4[EDAMode4["L2"] = 1] = "L2";
   return EDAMode4;
 })(EDAMode || {});
-var ETransactionVersion = /* @__PURE__ */ ((ETransactionVersion5) => {
-  ETransactionVersion5["V0"] = "0x0";
-  ETransactionVersion5["V1"] = "0x1";
-  ETransactionVersion5["V2"] = "0x2";
-  ETransactionVersion5["V3"] = "0x3";
-  ETransactionVersion5["F0"] = "0x100000000000000000000000000000000";
-  ETransactionVersion5["F1"] = "0x100000000000000000000000000000001";
-  ETransactionVersion5["F2"] = "0x100000000000000000000000000000002";
-  ETransactionVersion5["F3"] = "0x100000000000000000000000000000003";
-  return ETransactionVersion5;
+var ETransactionVersion = /* @__PURE__ */ ((ETransactionVersion10) => {
+  ETransactionVersion10["V0"] = "0x0";
+  ETransactionVersion10["V1"] = "0x1";
+  ETransactionVersion10["V2"] = "0x2";
+  ETransactionVersion10["V3"] = "0x3";
+  ETransactionVersion10["F0"] = "0x100000000000000000000000000000000";
+  ETransactionVersion10["F1"] = "0x100000000000000000000000000000001";
+  ETransactionVersion10["F2"] = "0x100000000000000000000000000000002";
+  ETransactionVersion10["F3"] = "0x100000000000000000000000000000003";
+  return ETransactionVersion10;
 })(ETransactionVersion || {});
-var ETransactionVersion2 = /* @__PURE__ */ ((ETransactionVersion24) => {
-  ETransactionVersion24["V0"] = "0x0";
-  ETransactionVersion24["V1"] = "0x1";
-  ETransactionVersion24["V2"] = "0x2";
-  ETransactionVersion24["F0"] = "0x100000000000000000000000000000000";
-  ETransactionVersion24["F1"] = "0x100000000000000000000000000000001";
-  ETransactionVersion24["F2"] = "0x100000000000000000000000000000002";
-  return ETransactionVersion24;
+var ETransactionVersion2 = /* @__PURE__ */ ((ETransactionVersion25) => {
+  ETransactionVersion25["V0"] = "0x0";
+  ETransactionVersion25["V1"] = "0x1";
+  ETransactionVersion25["V2"] = "0x2";
+  ETransactionVersion25["F0"] = "0x100000000000000000000000000000000";
+  ETransactionVersion25["F1"] = "0x100000000000000000000000000000001";
+  ETransactionVersion25["F2"] = "0x100000000000000000000000000000002";
+  return ETransactionVersion25;
 })(ETransactionVersion2 || {});
-var ETransactionVersion3 = /* @__PURE__ */ ((ETransactionVersion34) => {
-  ETransactionVersion34["V3"] = "0x3";
-  ETransactionVersion34["F3"] = "0x100000000000000000000000000000003";
-  return ETransactionVersion34;
+var ETransactionVersion3 = /* @__PURE__ */ ((ETransactionVersion36) => {
+  ETransactionVersion36["V3"] = "0x3";
+  ETransactionVersion36["F3"] = "0x100000000000000000000000000000003";
+  return ETransactionVersion36;
 })(ETransactionVersion3 || {});
 
-// src/types/api/rpcspec_0_7/index.ts
-var rpcspec_0_7_exports = {};
-__export(rpcspec_0_7_exports, {
-  EBlockTag: () => EBlockTag2,
-  EDAMode: () => EDAMode2,
-  EDataAvailabilityMode: () => EDataAvailabilityMode2,
-  ESimulationFlag: () => ESimulationFlag2,
-  ETransactionExecutionStatus: () => ETransactionExecutionStatus2,
-  ETransactionFinalityStatus: () => ETransactionFinalityStatus2,
-  ETransactionStatus: () => ETransactionStatus2,
-  ETransactionType: () => ETransactionType2,
-  ETransactionVersion: () => ETransactionVersion4,
-  ETransactionVersion2: () => ETransactionVersion22,
-  ETransactionVersion3: () => ETransactionVersion32,
-  Errors: () => errors_exports2,
-  SPEC: () => components_exports2
-});
-
-// src/types/api/rpcspec_0_7/errors.ts
-var errors_exports2 = {};
-
-// src/types/api/rpcspec_0_7/components.ts
-var components_exports2 = {};
-
-// src/types/api/rpcspec_0_7/nonspec.ts
-var ETransactionType2 = /* @__PURE__ */ ((ETransactionType3) => {
-  ETransactionType3["DECLARE"] = "DECLARE";
-  ETransactionType3["DEPLOY"] = "DEPLOY";
-  ETransactionType3["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-  ETransactionType3["INVOKE"] = "INVOKE";
-  ETransactionType3["L1_HANDLER"] = "L1_HANDLER";
-  return ETransactionType3;
-})(ETransactionType2 || {});
-var ESimulationFlag2 = /* @__PURE__ */ ((ESimulationFlag3) => {
-  ESimulationFlag3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-  ESimulationFlag3["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
-  return ESimulationFlag3;
-})(ESimulationFlag2 || {});
-var ETransactionStatus2 = /* @__PURE__ */ ((ETransactionStatus3) => {
-  ETransactionStatus3["RECEIVED"] = "RECEIVED";
-  ETransactionStatus3["REJECTED"] = "REJECTED";
-  ETransactionStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  ETransactionStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  return ETransactionStatus3;
-})(ETransactionStatus2 || {});
-var ETransactionFinalityStatus2 = /* @__PURE__ */ ((ETransactionFinalityStatus3) => {
-  ETransactionFinalityStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  ETransactionFinalityStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  return ETransactionFinalityStatus3;
-})(ETransactionFinalityStatus2 || {});
-var ETransactionExecutionStatus2 = /* @__PURE__ */ ((ETransactionExecutionStatus3) => {
-  ETransactionExecutionStatus3["SUCCEEDED"] = "SUCCEEDED";
-  ETransactionExecutionStatus3["REVERTED"] = "REVERTED";
-  return ETransactionExecutionStatus3;
-})(ETransactionExecutionStatus2 || {});
-var EBlockTag2 = /* @__PURE__ */ ((EBlockTag3) => {
-  EBlockTag3["LATEST"] = "latest";
-  EBlockTag3["PENDING"] = "pending";
-  return EBlockTag3;
-})(EBlockTag2 || {});
-var EDataAvailabilityMode2 = /* @__PURE__ */ ((EDataAvailabilityMode3) => {
-  EDataAvailabilityMode3["L1"] = "L1";
-  EDataAvailabilityMode3["L2"] = "L2";
-  return EDataAvailabilityMode3;
-})(EDataAvailabilityMode2 || {});
-var EDAMode2 = /* @__PURE__ */ ((EDAMode4) => {
-  EDAMode4[EDAMode4["L1"] = 0] = "L1";
-  EDAMode4[EDAMode4["L2"] = 1] = "L2";
-  return EDAMode4;
-})(EDAMode2 || {});
-var ETransactionVersion4 = /* @__PURE__ */ ((ETransactionVersion5) => {
-  ETransactionVersion5["V0"] = "0x0";
-  ETransactionVersion5["V1"] = "0x1";
-  ETransactionVersion5["V2"] = "0x2";
-  ETransactionVersion5["V3"] = "0x3";
-  ETransactionVersion5["F0"] = "0x100000000000000000000000000000000";
-  ETransactionVersion5["F1"] = "0x100000000000000000000000000000001";
-  ETransactionVersion5["F2"] = "0x100000000000000000000000000000002";
-  ETransactionVersion5["F3"] = "0x100000000000000000000000000000003";
-  return ETransactionVersion5;
-})(ETransactionVersion4 || {});
-var ETransactionVersion22 = /* @__PURE__ */ ((ETransactionVersion24) => {
-  ETransactionVersion24["V0"] = "0x0";
-  ETransactionVersion24["V1"] = "0x1";
-  ETransactionVersion24["V2"] = "0x2";
-  ETransactionVersion24["F0"] = "0x100000000000000000000000000000000";
-  ETransactionVersion24["F1"] = "0x100000000000000000000000000000001";
-  ETransactionVersion24["F2"] = "0x100000000000000000000000000000002";
-  return ETransactionVersion24;
-})(ETransactionVersion22 || {});
-var ETransactionVersion32 = /* @__PURE__ */ ((ETransactionVersion34) => {
-  ETransactionVersion34["V3"] = "0x3";
-  ETransactionVersion34["F3"] = "0x100000000000000000000000000000003";
-  return ETransactionVersion34;
-})(ETransactionVersion32 || {});
+// src/types/api/index.ts
+var RPCSPEC07 = __toESM(require("starknet-types-07"));
+__reExport(api_exports, require("starknet-types-07"));
 
 // src/utils/encode.ts
 var encode_exports = {};
@@ -559,7 +456,7 @@ __export(types_exports, {
   TransactionFinalityStatus: () => TransactionFinalityStatus,
   TransactionStatus: () => TransactionStatus,
   TransactionType: () => TransactionType,
-  TypedDataRevision: () => import_starknet_types.TypedDataRevision,
+  TypedDataRevision: () => import_starknet_types_07.TypedDataRevision,
   Uint: () => Uint,
   ValidateType: () => ValidateType
 });
@@ -647,7 +544,7 @@ var BlockTag = /* @__PURE__ */ ((BlockTag2) => {
 })(BlockTag || {});
 
 // src/types/typedData.ts
-var import_starknet_types = require("starknet-types");
+var import_starknet_types_07 = require("starknet-types-07");
 
 // src/utils/assert.ts
 function assert(condition, message) {
@@ -2855,7 +2752,7 @@ function calculateInvokeTransactionHash(senderAddress, version, compiledCalldata
 
 // src/utils/hash/transactionHash/index.ts
 function isV3InvokeTx(args) {
-  return ["0x3" /* V3 */, "0x100000000000000000000000000000003" /* F3 */].includes(
+  return [api_exports.ETransactionVersion.V3, api_exports.ETransactionVersion.F3].includes(
     args.version
   );
 }
@@ -2885,7 +2782,7 @@ function calculateInvokeTransactionHash2(args) {
   );
 }
 function isV3DeclareTx(args) {
-  return ["0x3" /* V3 */, "0x100000000000000000000000000000003" /* F3 */].includes(
+  return [api_exports.ETransactionVersion.V3, api_exports.ETransactionVersion.F3].includes(
     args.version
   );
 }
@@ -2917,7 +2814,7 @@ function calculateDeclareTransactionHash3(args) {
   );
 }
 function isV3DeployAccountTx(args) {
-  return ["0x3" /* V3 */, "0x100000000000000000000000000000003" /* F3 */].includes(
+  return [api_exports.ETransactionVersion.V3, api_exports.ETransactionVersion.F3].includes(
     args.version
   );
 }
@@ -3212,19 +3109,19 @@ function estimateFeeToBounds(estimate, amountOverhead = 50 /* L1_BOUND_MAX_AMOUN
   };
 }
 function intDAM(dam) {
-  if (dam === "L1" /* L1 */)
-    return 0 /* L1 */;
-  if (dam === "L2" /* L2 */)
-    return 1 /* L2 */;
+  if (dam === api_exports.EDataAvailabilityMode.L1)
+    return api_exports.EDAMode.L1;
+  if (dam === api_exports.EDataAvailabilityMode.L2)
+    return api_exports.EDAMode.L2;
   throw Error("EDAM conversion");
 }
 function toTransactionVersion(defaultVersion, providedVersion) {
   const providedVersion0xs = providedVersion ? toHex(providedVersion) : void 0;
   const defaultVersion0xs = toHex(defaultVersion);
-  if (providedVersion && !Object.values(ETransactionVersion4).includes(providedVersion0xs)) {
+  if (providedVersion && !Object.values(api_exports.ETransactionVersion).includes(providedVersion0xs)) {
     throw Error(`providedVersion ${providedVersion} is not ETransactionVersion`);
   }
-  if (!Object.values(ETransactionVersion4).includes(defaultVersion0xs)) {
+  if (!Object.values(api_exports.ETransactionVersion).includes(defaultVersion0xs)) {
     throw Error(`defaultVersion ${defaultVersion} is not ETransactionVersion`);
   }
   return providedVersion ? providedVersion0xs : defaultVersion0xs;
@@ -3233,14 +3130,14 @@ function toFeeVersion(providedVersion) {
   if (!providedVersion)
     return void 0;
   const version = toHex(providedVersion);
-  if (version === "0x0" /* V0 */)
-    return "0x100000000000000000000000000000000" /* F0 */;
-  if (version === "0x1" /* V1 */)
-    return "0x100000000000000000000000000000001" /* F1 */;
-  if (version === "0x2" /* V2 */)
-    return "0x100000000000000000000000000000002" /* F2 */;
-  if (version === "0x3" /* V3 */)
-    return "0x100000000000000000000000000000003" /* F3 */;
+  if (version === api_exports.ETransactionVersion.V0)
+    return api_exports.ETransactionVersion.F0;
+  if (version === api_exports.ETransactionVersion.V1)
+    return api_exports.ETransactionVersion.F1;
+  if (version === api_exports.ETransactionVersion.V2)
+    return api_exports.ETransactionVersion.F2;
+  if (version === api_exports.ETransactionVersion.V3)
+    return api_exports.ETransactionVersion.F3;
   throw Error(`toFeeVersion: ${version} is not supported`);
 }
 function v3Details(details) {
@@ -3248,16 +3145,16 @@ function v3Details(details) {
     tip: details.tip || 0,
     paymasterData: details.paymasterData || [],
     accountDeploymentData: details.accountDeploymentData || [],
-    nonceDataAvailabilityMode: details.nonceDataAvailabilityMode || "L1" /* L1 */,
-    feeDataAvailabilityMode: details.feeDataAvailabilityMode || "L1" /* L1 */,
+    nonceDataAvailabilityMode: details.nonceDataAvailabilityMode || api_exports.EDataAvailabilityMode.L1,
+    feeDataAvailabilityMode: details.feeDataAvailabilityMode || api_exports.EDataAvailabilityMode.L1,
     resourceBounds: details.resourceBounds ?? estimateFeeToBounds(ZERO)
   };
 }
 function reduceV2(providedVersion) {
-  if (providedVersion === "0x100000000000000000000000000000002" /* F2 */)
-    return "0x100000000000000000000000000000001" /* F1 */;
-  if (providedVersion === "0x2" /* V2 */)
-    return "0x1" /* V1 */;
+  if (providedVersion === api_exports.ETransactionVersion.F2)
+    return api_exports.ETransactionVersion.F1;
+  if (providedVersion === api_exports.ETransactionVersion.V2)
+    return api_exports.ETransactionVersion.V1;
   return providedVersion;
 }
 
@@ -3355,9 +3252,10 @@ function parseContract(contract) {
   return createSierraContractClass(parsedContract);
 }
 var getDefaultNodeUrl = (networkName, mute = false) => {
-  if (!mute)
+  if (!mute) {
     console.warn("Using default public node url, please provide nodeUrl in provider options!");
-  const nodes = RPC_NODES[networkName ?? "SN_GOERLI" /* SN_GOERLI */];
+  }
+  const nodes = RPC_NODES[networkName ?? "SN_SEPOLIA" /* SN_SEPOLIA */];
   const randIdx = Math.floor(Math.random() * nodes.length);
   return nodes[randIdx];
 };
@@ -3380,10 +3278,14 @@ var Block = class {
   tag = null;
   setIdentifier(__identifier) {
     if (isString(__identifier)) {
-      if (isHex(__identifier)) {
+      if (isDecimalString(__identifier)) {
+        this.number = parseInt(__identifier, 10);
+      } else if (isHex(__identifier)) {
         this.hash = __identifier;
       } else if (validBlockTags.includes(__identifier)) {
         this.tag = __identifier;
+      } else {
+        throw TypeError(`Block identifier unmanaged: ${__identifier}`);
       }
     } else if (isBigInt(__identifier)) {
       this.hash = toHex(__identifier);
@@ -3392,6 +3294,9 @@ var Block = class {
     } else {
       this.tag = "pending" /* pending */;
     }
+    if (isNumber(this.number) && this.number < 0) {
+      throw TypeError(`Block number (${this.number}) can't be negative`);
+    }
   }
   constructor(_identifier) {
     this.setIdentifier(_identifier);
@@ -3421,15 +3326,10 @@ var Block = class {
   }
   valueOf = () => this.number;
   toString = () => this.hash;
-  /*   get sequencerIdentifier(): SequencerIdentifier {
-    return this.hash !== null
-      ? { blockHash: this.hash as string }
-      : { blockNumber: (this.number ?? this.tag) as BlockNumber };
-  } */
 };
 function isV3Tx(details) {
-  const version = details.version ? toHex(details.version) : "0x3" /* V3 */;
-  return version === "0x3" /* V3 */ || version === "0x100000000000000000000000000000003" /* F3 */;
+  const version = details.version ? toHex(details.version) : api_exports.ETransactionVersion.V3;
+  return version === api_exports.ETransactionVersion.V3 || version === api_exports.ETransactionVersion.F3;
 }
 function isVersion(version, response) {
   const [majorS, minorS] = version.split(".");
@@ -3544,10 +3444,10 @@ function buildUDCCall(payload, address) {
 }
 function getVersionsByType(versionType) {
   return versionType === "fee" ? {
-    v1: "0x100000000000000000000000000000001" /* F1 */,
-    v2: "0x100000000000000000000000000000002" /* F2 */,
-    v3: "0x100000000000000000000000000000003" /* F3 */
-  } : { v1: "0x1" /* V1 */, v2: "0x2" /* V2 */, v3: "0x3" /* V3 */ };
+    v1: api_exports.ETransactionVersion.F1,
+    v2: api_exports.ETransactionVersion.F2,
+    v3: api_exports.ETransactionVersion.F3
+  } : { v1: api_exports.ETransactionVersion.V1, v2: api_exports.ETransactionVersion.V2, v3: api_exports.ETransactionVersion.V3 };
 }
 
 // src/channel/rpc_0_6.ts
@@ -4035,7 +3935,6 @@ var RpcChannel = class {
       return {
         // v0 v1 v3
         type: rpcspec_0_6_exports.ETransactionType.INVOKE,
-        // TODO: Diff between sequencer and rpc invoke type
         sender_address: invocation.contractAddress,
         calldata: CallData.toHex(invocation.calldata),
         version: toHex(invocation.version || defaultVersions.v3),
@@ -4254,9 +4153,9 @@ var RpcChannel2 = class {
     const block_id = new Block(blockIdentifier).identifier;
     const simulationFlags = [];
     if (skipValidate)
-      simulationFlags.push(rpcspec_0_7_exports.ESimulationFlag.SKIP_VALIDATE);
+      simulationFlags.push(RPCSPEC07.ESimulationFlag.SKIP_VALIDATE);
     if (skipFeeCharge)
-      simulationFlags.push(rpcspec_0_7_exports.ESimulationFlag.SKIP_FEE_CHARGE);
+      simulationFlags.push(RPCSPEC07.ESimulationFlag.SKIP_FEE_CHARGE);
     return this.fetchEndpoint("starknet_simulateTransactions", {
       block_id,
       transactions: invocations.map((it) => this.buildTransaction(it)),
@@ -4270,15 +4169,15 @@ var RpcChannel2 = class {
     let isErrorState = false;
     const retryInterval = options?.retryInterval ?? 5e3;
     const errorStates = options?.errorStates ?? [
-      rpcspec_0_7_exports.ETransactionStatus.REJECTED
+      RPCSPEC07.ETransactionStatus.REJECTED
       // TODO: commented out to preserve the long-standing behavior of "reverted" not being treated as an error by default
       // should decide which behavior to keep in the future
       // RPC.ETransactionExecutionStatus.REVERTED,
     ];
     const successStates = options?.successStates ?? [
-      rpcspec_0_7_exports.ETransactionExecutionStatus.SUCCEEDED,
-      rpcspec_0_7_exports.ETransactionStatus.ACCEPTED_ON_L2,
-      rpcspec_0_7_exports.ETransactionStatus.ACCEPTED_ON_L1
+      RPCSPEC07.ETransactionExecutionStatus.SUCCEEDED,
+      RPCSPEC07.ETransactionStatus.ACCEPTED_ON_L2,
+      RPCSPEC07.ETransactionStatus.ACCEPTED_ON_L1
     ];
     let txStatus;
     while (!onchain) {
@@ -4363,7 +4262,7 @@ var RpcChannel2 = class {
     let flags = {};
     if (!isVersion("0.5", await this.getSpecVersion())) {
       flags = {
-        simulation_flags: skipValidate ? [rpcspec_0_7_exports.ESimulationFlag.SKIP_VALIDATE] : []
+        simulation_flags: skipValidate ? [RPCSPEC07.ESimulationFlag.SKIP_VALIDATE] : []
       };
     }
     return this.fetchEndpoint("starknet_estimateFee", {
@@ -4379,9 +4278,9 @@ var RpcChannel2 = class {
         invoke_transaction: {
           sender_address: functionInvocation.contractAddress,
           calldata: CallData.toHex(functionInvocation.calldata),
-          type: rpcspec_0_7_exports.ETransactionType.INVOKE,
+          type: RPCSPEC07.ETransactionType.INVOKE,
           max_fee: toHex(details.maxFee || 0),
-          version: rpcspec_0_7_exports.ETransactionVersion.V1,
+          version: RPCSPEC07.ETransactionVersion.V1,
           signature: signatureToHexArray(functionInvocation.signature),
           nonce: toHex(details.nonce)
         }
@@ -4389,10 +4288,10 @@ var RpcChannel2 = class {
     } else {
       promise = this.fetchEndpoint("starknet_addInvokeTransaction", {
         invoke_transaction: {
-          type: rpcspec_0_7_exports.ETransactionType.INVOKE,
+          type: RPCSPEC07.ETransactionType.INVOKE,
           sender_address: functionInvocation.contractAddress,
           calldata: CallData.toHex(functionInvocation.calldata),
-          version: rpcspec_0_7_exports.ETransactionVersion.V3,
+          version: RPCSPEC07.ETransactionVersion.V3,
           signature: signatureToHexArray(functionInvocation.signature),
           nonce: toHex(details.nonce),
           resource_bounds: details.resourceBounds,
@@ -4411,13 +4310,13 @@ var RpcChannel2 = class {
     if (!isSierra(contract) && !isV3Tx(details)) {
       promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
         declare_transaction: {
-          type: rpcspec_0_7_exports.ETransactionType.DECLARE,
+          type: RPCSPEC07.ETransactionType.DECLARE,
           contract_class: {
             program: contract.program,
             entry_points_by_type: contract.entry_points_by_type,
             abi: contract.abi
           },
-          version: rpcspec_0_7_exports.ETransactionVersion.V1,
+          version: RPCSPEC07.ETransactionVersion.V1,
           max_fee: toHex(details.maxFee || 0),
           signature: signatureToHexArray(signature),
           sender_address: senderAddress,
@@ -4427,7 +4326,7 @@ var RpcChannel2 = class {
     } else if (isSierra(contract) && !isV3Tx(details)) {
       promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
         declare_transaction: {
-          type: rpcspec_0_7_exports.ETransactionType.DECLARE,
+          type: RPCSPEC07.ETransactionType.DECLARE,
           contract_class: {
             sierra_program: decompressProgram(contract.sierra_program),
             contract_class_version: contract.contract_class_version,
@@ -4435,7 +4334,7 @@ var RpcChannel2 = class {
             abi: contract.abi
           },
           compiled_class_hash: compiledClassHash || "",
-          version: rpcspec_0_7_exports.ETransactionVersion.V2,
+          version: RPCSPEC07.ETransactionVersion.V2,
           max_fee: toHex(details.maxFee || 0),
           signature: signatureToHexArray(signature),
           sender_address: senderAddress,
@@ -4445,10 +4344,10 @@ var RpcChannel2 = class {
     } else if (isSierra(contract) && isV3Tx(details)) {
       promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
         declare_transaction: {
-          type: rpcspec_0_7_exports.ETransactionType.DECLARE,
+          type: RPCSPEC07.ETransactionType.DECLARE,
           sender_address: senderAddress,
           compiled_class_hash: compiledClassHash || "",
-          version: rpcspec_0_7_exports.ETransactionVersion.V3,
+          version: RPCSPEC07.ETransactionVersion.V3,
           signature: signatureToHexArray(signature),
           nonce: toHex(details.nonce),
           contract_class: {
@@ -4478,9 +4377,9 @@ var RpcChannel2 = class {
           constructor_calldata: CallData.toHex(constructorCalldata || []),
           class_hash: toHex(classHash),
           contract_address_salt: toHex(addressSalt || 0),
-          type: rpcspec_0_7_exports.ETransactionType.DEPLOY_ACCOUNT,
+          type: RPCSPEC07.ETransactionType.DEPLOY_ACCOUNT,
           max_fee: toHex(details.maxFee || 0),
-          version: rpcspec_0_7_exports.ETransactionVersion.V1,
+          version: RPCSPEC07.ETransactionVersion.V1,
           signature: signatureToHexArray(signature),
           nonce: toHex(details.nonce)
         }
@@ -4488,8 +4387,8 @@ var RpcChannel2 = class {
     } else {
       promise = this.fetchEndpoint("starknet_addDeployAccountTransaction", {
         deploy_account_transaction: {
-          type: rpcspec_0_7_exports.ETransactionType.DEPLOY_ACCOUNT,
-          version: rpcspec_0_7_exports.ETransactionVersion.V3,
+          type: RPCSPEC07.ETransactionType.DEPLOY_ACCOUNT,
+          version: RPCSPEC07.ETransactionVersion.V3,
           signature: signatureToHexArray(signature),
           nonce: toHex(details.nonce),
           contract_address_salt: toHex(addressSalt || 0),
@@ -4572,8 +4471,7 @@ var RpcChannel2 = class {
     if (invocation.type === "INVOKE_FUNCTION" /* INVOKE */) {
       return {
         // v0 v1 v3
-        type: rpcspec_0_7_exports.ETransactionType.INVOKE,
-        // TODO: Diff between sequencer and rpc invoke type
+        type: RPCSPEC07.ETransactionType.INVOKE,
         sender_address: invocation.contractAddress,
         calldata: CallData.toHex(invocation.calldata),
         version: toHex(invocation.version || defaultVersions.v3),
@@ -4689,6 +4587,9 @@ var RPCResponseParser = class {
       abi: isString(res.abi) ? JSON.parse(res.abi) : res.abi
     };
   }
+  parseL1GasPriceResponse(res) {
+    return res.l1_gas_price.price_in_wei;
+  }
 };
 
 // src/utils/transactionReceipt.ts
@@ -4787,6 +4688,9 @@ var RpcProvider = class {
   async getBlockWithTxs(blockIdentifier) {
     return this.channel.getBlockWithTxs(blockIdentifier);
   }
+  async getL1GasPrice(blockIdentifier) {
+    return this.channel.getBlockWithTxHashes(blockIdentifier).then(this.responseParser.parseL1GasPriceResponse);
+  }
   async getBlockWithReceipts(blockIdentifier) {
     if (this.channel instanceof rpc_0_6_exports.RpcChannel)
       throw new LibraryError("Unsupported method for RPC version");
@@ -5437,7 +5341,7 @@ var SignerInterface = class {
 // src/utils/typedData.ts
 var typedData_exports = {};
 __export(typedData_exports, {
-  TypedDataRevision: () => import_starknet_types.TypedDataRevision,
+  TypedDataRevision: () => import_starknet_types_07.TypedDataRevision,
   encodeData: () => encodeData,
   encodeType: () => encodeType,
   encodeValue: () => encodeValue,
@@ -5541,14 +5445,14 @@ var presetTypes = {
   )
 };
 var revisionConfiguration = {
-  [import_starknet_types.TypedDataRevision.Active]: {
+  [import_starknet_types_07.TypedDataRevision.Active]: {
     domain: "StarknetDomain",
     hashMethod: computePoseidonHashOnElements,
     hashMerkleMethod: computePoseidonHash,
     escapeTypeString: (s) => `"${s}"`,
     presetTypes
   },
-  [import_starknet_types.TypedDataRevision.Legacy]: {
+  [import_starknet_types_07.TypedDataRevision.Legacy]: {
     domain: "StarkNetDomain",
     hashMethod: computePedersenHashOnElements,
     hashMerkleMethod: computePedersenHash,
@@ -5561,10 +5465,10 @@ function assertRange(data, type, { min, max }) {
   assert(value >= min && value <= max, `${value} (${type}) is out of bounds [${min}, ${max}]`);
 }
 function identifyRevision({ types, domain }) {
-  if (revisionConfiguration[import_starknet_types.TypedDataRevision.Active].domain in types && domain.revision === import_starknet_types.TypedDataRevision.Active)
-    return import_starknet_types.TypedDataRevision.Active;
-  if (revisionConfiguration[import_starknet_types.TypedDataRevision.Legacy].domain in types && (domain.revision ?? import_starknet_types.TypedDataRevision.Legacy) === import_starknet_types.TypedDataRevision.Legacy)
-    return import_starknet_types.TypedDataRevision.Legacy;
+  if (revisionConfiguration[import_starknet_types_07.TypedDataRevision.Active].domain in types && domain.revision === import_starknet_types_07.TypedDataRevision.Active)
+    return import_starknet_types_07.TypedDataRevision.Active;
+  if (revisionConfiguration[import_starknet_types_07.TypedDataRevision.Legacy].domain in types && (domain.revision ?? import_starknet_types_07.TypedDataRevision.Legacy) === import_starknet_types_07.TypedDataRevision.Legacy)
+    return import_starknet_types_07.TypedDataRevision.Legacy;
   return void 0;
 }
 function getHex(value) {
@@ -5589,10 +5493,10 @@ function prepareSelector(selector) {
 function isMerkleTreeType(type) {
   return type.type === "merkletree";
 }
-function getDependencies(types, type, dependencies = [], contains = "", revision = import_starknet_types.TypedDataRevision.Legacy) {
+function getDependencies(types, type, dependencies = [], contains = "", revision = import_starknet_types_07.TypedDataRevision.Legacy) {
   if (type[type.length - 1] === "*") {
     type = type.slice(0, -1);
-  } else if (revision === import_starknet_types.TypedDataRevision.Active) {
+  } else if (revision === import_starknet_types_07.TypedDataRevision.Active) {
     if (type === "enum") {
       type = contains;
     } else if (type.match(/^\(.*\)$/)) {
@@ -5630,8 +5534,8 @@ function getMerkleTreeType(types, ctx) {
   }
   return "raw";
 }
-function encodeType(types, type, revision = import_starknet_types.TypedDataRevision.Legacy) {
-  const allTypes = revision === import_starknet_types.TypedDataRevision.Active ? { ...types, ...revisionConfiguration[revision].presetTypes } : types;
+function encodeType(types, type, revision = import_starknet_types_07.TypedDataRevision.Legacy) {
+  const allTypes = revision === import_starknet_types_07.TypedDataRevision.Active ? { ...types, ...revisionConfiguration[revision].presetTypes } : types;
   const [primary, ...dependencies] = getDependencies(
     allTypes,
     type,
@@ -5643,17 +5547,17 @@ function encodeType(types, type, revision = import_starknet_types.TypedDataRevis
   const esc = revisionConfiguration[revision].escapeTypeString;
   return newTypes.map((dependency) => {
     const dependencyElements = allTypes[dependency].map((t) => {
-      const targetType = t.type === "enum" && revision === import_starknet_types.TypedDataRevision.Active ? t.contains : t.type;
+      const targetType = t.type === "enum" && revision === import_starknet_types_07.TypedDataRevision.Active ? t.contains : t.type;
       const typeString = targetType.match(/^\(.*\)$/) ? `(${targetType.slice(1, -1).split(",").map((e) => e ? esc(e) : e).join(",")})` : esc(targetType);
       return `${esc(t.name)}:${typeString}`;
     });
     return `${esc(dependency)}(${dependencyElements})`;
   }).join("");
 }
-function getTypeHash(types, type, revision = import_starknet_types.TypedDataRevision.Legacy) {
+function getTypeHash(types, type, revision = import_starknet_types_07.TypedDataRevision.Legacy) {
   return getSelectorFromName(encodeType(types, type, revision));
 }
-function encodeValue(types, type, data, ctx = {}, revision = import_starknet_types.TypedDataRevision.Legacy) {
+function encodeValue(types, type, data, ctx = {}, revision = import_starknet_types_07.TypedDataRevision.Legacy) {
   if (types[type]) {
     return [type, getStructHash(types, type, data, revision)];
   }
@@ -5676,7 +5580,7 @@ function encodeValue(types, type, data, ctx = {}, revision = import_starknet_typ
   }
   switch (type) {
     case "enum": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         const [variantKey, variantData] = Object.entries(data)[0];
         const parentType = types[ctx.parent][0];
         const enumType = types[parentType.contains];
@@ -5710,7 +5614,7 @@ function encodeValue(types, type, data, ctx = {}, revision = import_starknet_typ
       return ["felt", prepareSelector(data)];
     }
     case "string": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         const byteArray = byteArrayFromString(data);
         const elements = [
           byteArray.data.length,
@@ -5723,7 +5627,7 @@ function encodeValue(types, type, data, ctx = {}, revision = import_starknet_typ
       return [type, getHex(data)];
     }
     case "i128": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         const value = BigInt(data);
         assertRange(value, type, RANGE_I128);
         return [type, getHex(value < 0n ? PRIME + value : value)];
@@ -5732,40 +5636,40 @@ function encodeValue(types, type, data, ctx = {}, revision = import_starknet_typ
     }
     case "timestamp":
     case "u128": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         assertRange(data, type, RANGE_U128);
       }
       return [type, getHex(data)];
     }
     case "felt":
     case "shortstring": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         assertRange(getHex(data), type, RANGE_FELT);
       }
       return [type, getHex(data)];
     }
     case "ClassHash":
     case "ContractAddress": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         assertRange(data, type, RANGE_FELT);
       }
       return [type, getHex(data)];
     }
     case "bool": {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         assert(typeof data === "boolean", `Type mismatch for ${type} ${data}`);
       }
       return [type, getHex(data)];
     }
     default: {
-      if (revision === import_starknet_types.TypedDataRevision.Active) {
+      if (revision === import_starknet_types_07.TypedDataRevision.Active) {
         throw new Error(`Unsupported type: ${type}`);
       }
       return [type, getHex(data)];
     }
   }
 }
-function encodeData(types, type, data, revision = import_starknet_types.TypedDataRevision.Legacy) {
+function encodeData(types, type, data, revision = import_starknet_types_07.TypedDataRevision.Legacy) {
   const targetType = types[type] ?? revisionConfiguration[revision].presetTypes[type];
   const [returnTypes, values] = targetType.reduce(
     ([ts, vs], field) => {
@@ -5784,7 +5688,7 @@ function encodeData(types, type, data, revision = import_starknet_types.TypedDat
   );
   return [returnTypes, values];
 }
-function getStructHash(types, type, data, revision = import_starknet_types.TypedDataRevision.Legacy) {
+function getStructHash(types, type, data, revision = import_starknet_types_07.TypedDataRevision.Legacy) {
   return revisionConfiguration[revision].hashMethod(encodeData(types, type, data, revision)[1]);
 }
 function getMessageHash(typedData, account) {
@@ -5818,7 +5722,7 @@ var Signer = class {
   async signTransaction(transactions, details) {
     const compiledCalldata = getExecuteCalldata(transactions, details.cairoVersion);
     let msgHash;
-    if (Object.values(ETransactionVersion22).includes(details.version)) {
+    if (Object.values(api_exports.ETransactionVersion2).includes(details.version)) {
       const det = details;
       msgHash = calculateInvokeTransactionHash2({
         ...det,
@@ -5826,7 +5730,7 @@ var Signer = class {
         compiledCalldata,
         version: det.version
       });
-    } else if (Object.values(ETransactionVersion32).includes(details.version)) {
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
       const det = details;
       msgHash = calculateInvokeTransactionHash2({
         ...det,
@@ -5844,7 +5748,7 @@ var Signer = class {
   async signDeployAccountTransaction(details) {
     const compiledConstructorCalldata = CallData.compile(details.constructorCalldata);
     let msgHash;
-    if (Object.values(ETransactionVersion22).includes(details.version)) {
+    if (Object.values(api_exports.ETransactionVersion2).includes(details.version)) {
       const det = details;
       msgHash = calculateDeployAccountTransactionHash3({
         ...det,
@@ -5852,7 +5756,7 @@ var Signer = class {
         constructorCalldata: compiledConstructorCalldata,
         version: det.version
       });
-    } else if (Object.values(ETransactionVersion32).includes(details.version)) {
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
       const det = details;
       msgHash = calculateDeployAccountTransactionHash3({
         ...det,
@@ -5869,13 +5773,13 @@ var Signer = class {
   }
   async signDeclareTransaction(details) {
     let msgHash;
-    if (Object.values(ETransactionVersion22).includes(details.version)) {
+    if (Object.values(api_exports.ETransactionVersion2).includes(details.version)) {
       const det = details;
       msgHash = calculateDeclareTransactionHash3({
         ...det,
         version: det.version
       });
-    } else if (Object.values(ETransactionVersion32).includes(details.version)) {
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
       const det = details;
       msgHash = calculateDeclareTransactionHash3({
         ...det,
@@ -5942,7 +5846,7 @@ var EthSigner = class {
   async signTransaction(transactions, details) {
     const compiledCalldata = getExecuteCalldata(transactions, details.cairoVersion);
     let msgHash;
-    if (Object.values(ETransactionVersion22).includes(details.version)) {
+    if (Object.values(api_exports.ETransactionVersion2).includes(details.version)) {
       const det = details;
       msgHash = calculateInvokeTransactionHash2({
         ...det,
@@ -5950,7 +5854,7 @@ var EthSigner = class {
         compiledCalldata,
         version: det.version
       });
-    } else if (Object.values(ETransactionVersion32).includes(details.version)) {
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
       const det = details;
       msgHash = calculateInvokeTransactionHash2({
         ...det,
@@ -5972,7 +5876,7 @@ var EthSigner = class {
   async signDeployAccountTransaction(details) {
     const compiledConstructorCalldata = CallData.compile(details.constructorCalldata);
     let msgHash;
-    if (Object.values(ETransactionVersion22).includes(details.version)) {
+    if (Object.values(api_exports.ETransactionVersion2).includes(details.version)) {
       const det = details;
       msgHash = calculateDeployAccountTransactionHash3({
         ...det,
@@ -5980,7 +5884,7 @@ var EthSigner = class {
         constructorCalldata: compiledConstructorCalldata,
         version: det.version
       });
-    } else if (Object.values(ETransactionVersion32).includes(details.version)) {
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
       const det = details;
       msgHash = calculateDeployAccountTransactionHash3({
         ...det,
@@ -6001,13 +5905,13 @@ var EthSigner = class {
   }
   async signDeclareTransaction(details) {
     let msgHash;
-    if (Object.values(ETransactionVersion22).includes(details.version)) {
+    if (Object.values(api_exports.ETransactionVersion2).includes(details.version)) {
       const det = details;
       msgHash = calculateDeclareTransactionHash3({
         ...det,
         version: det.version
       });
-    } else if (Object.values(ETransactionVersion32).includes(details.version)) {
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
       const det = details;
       msgHash = calculateDeclareTransactionHash3({
         ...det,
@@ -6071,7 +5975,7 @@ var Account = class extends RpcProvider2 {
   address;
   cairoVersion;
   transactionVersion;
-  constructor(providerOrOptions, address, pkOrSigner, cairoVersion, transactionVersion = "0x2" /* V2 */) {
+  constructor(providerOrOptions, address, pkOrSigner, cairoVersion, transactionVersion = api_exports.ETransactionVersion.V2) {
     super(providerOrOptions);
     this.address = address.toLowerCase();
     this.signer = isString(pkOrSigner) || pkOrSigner instanceof Uint8Array ? new Signer(pkOrSigner) : pkOrSigner;
@@ -6082,11 +5986,11 @@ var Account = class extends RpcProvider2 {
   }
   // provided version or contract based preferred transactionVersion
   getPreferredVersion(type12, type3) {
-    if (this.transactionVersion === "0x3" /* V3 */)
+    if (this.transactionVersion === api_exports.ETransactionVersion.V3)
       return type3;
-    if (this.transactionVersion === "0x2" /* V2 */)
+    if (this.transactionVersion === api_exports.ETransactionVersion.V2)
       return type12;
-    return "0x3" /* V3 */;
+    return api_exports.ETransactionVersion.V3;
   }
   async getNonce(blockIdentifier) {
     return super.getNonceForAddress(this.address, blockIdentifier);
@@ -6122,7 +6026,7 @@ var Account = class extends RpcProvider2 {
     const transactions = Array.isArray(calls) ? calls : [calls];
     const nonce = toBigInt(providedNonce ?? await this.getNonce());
     const version = toTransactionVersion(
-      this.getPreferredVersion("0x100000000000000000000000000000001" /* F1 */, "0x100000000000000000000000000000003" /* F3 */),
+      this.getPreferredVersion(api_exports.ETransactionVersion.F1, api_exports.ETransactionVersion.F3),
       toFeeVersion(providedVersion)
     );
     const chainId = await this.getChainId();
@@ -6153,7 +6057,7 @@ var Account = class extends RpcProvider2 {
     } = details;
     const nonce = toBigInt(providedNonce ?? await this.getNonce());
     const version = toTransactionVersion(
-      !isSierra(payload.contract) ? "0x100000000000000000000000000000001" /* F1 */ : this.getPreferredVersion("0x100000000000000000000000000000002" /* F2 */, "0x100000000000000000000000000000003" /* F3 */),
+      !isSierra(payload.contract) ? api_exports.ETransactionVersion.F1 : this.getPreferredVersion(api_exports.ETransactionVersion.F2, api_exports.ETransactionVersion.F3),
       toFeeVersion(providedVersion)
     );
     const chainId = await this.getChainId();
@@ -6183,7 +6087,7 @@ var Account = class extends RpcProvider2 {
   }, details = {}) {
     const { blockIdentifier, version: providedVersion, skipValidate = true } = details;
     const version = toTransactionVersion(
-      this.getPreferredVersion("0x100000000000000000000000000000001" /* F1 */, "0x100000000000000000000000000000003" /* F3 */),
+      this.getPreferredVersion(api_exports.ETransactionVersion.F1, api_exports.ETransactionVersion.F3),
       toFeeVersion(providedVersion)
     );
     const nonce = ZERO;
@@ -6219,10 +6123,10 @@ var Account = class extends RpcProvider2 {
     const accountInvocations = await this.accountInvocationsFactory(invocations, {
       ...v3Details(details),
       versions: [
-        "0x100000000000000000000000000000001" /* F1 */,
+        api_exports.ETransactionVersion.F1,
         // non-sierra
         toTransactionVersion(
-          this.getPreferredVersion("0x100000000000000000000000000000002" /* F2 */, "0x100000000000000000000000000000003" /* F3 */),
+          this.getPreferredVersion(api_exports.ETransactionVersion.F2, api_exports.ETransactionVersion.F3),
           version
         )
         // sierra
@@ -6241,10 +6145,10 @@ var Account = class extends RpcProvider2 {
     const accountInvocations = await this.accountInvocationsFactory(invocations, {
       ...v3Details(details),
       versions: [
-        "0x1" /* V1 */,
+        api_exports.ETransactionVersion.V1,
         // non-sierra
         toTransactionVersion(
-          this.getPreferredVersion("0x2" /* V2 */, "0x3" /* V3 */),
+          this.getPreferredVersion(api_exports.ETransactionVersion.V2, api_exports.ETransactionVersion.V3),
           version
         )
       ],
@@ -6263,7 +6167,7 @@ var Account = class extends RpcProvider2 {
     const calls = Array.isArray(transactions) ? transactions : [transactions];
     const nonce = toBigInt(details.nonce ?? await this.getNonce());
     const version = toTransactionVersion(
-      this.getPreferredVersion("0x1" /* V1 */, "0x3" /* V3 */),
+      this.getPreferredVersion(api_exports.ETransactionVersion.V1, api_exports.ETransactionVersion.V3),
       // TODO: does this depend on cairo version ?
       details.version
     );
@@ -6321,7 +6225,7 @@ var Account = class extends RpcProvider2 {
     const declareContractPayload = extractContractHashes(payload);
     const { nonce, version: providedVersion } = details;
     const version = toTransactionVersion(
-      !isSierra(payload.contract) ? "0x1" /* V1 */ : this.getPreferredVersion("0x2" /* V2 */, "0x3" /* V3 */),
+      !isSierra(payload.contract) ? api_exports.ETransactionVersion.V1 : this.getPreferredVersion(api_exports.ETransactionVersion.V2, api_exports.ETransactionVersion.V3),
       providedVersion
     );
     const estimate = await this.getUniversalSuggestedFee(
@@ -6385,7 +6289,7 @@ var Account = class extends RpcProvider2 {
     contractAddress: providedContractAddress
   }, details = {}) {
     const version = toTransactionVersion(
-      this.getPreferredVersion("0x1" /* V1 */, "0x3" /* V3 */),
+      this.getPreferredVersion(api_exports.ETransactionVersion.V1, api_exports.ETransactionVersion.V3),
       details.version
     );
     const nonce = ZERO;
@@ -6467,7 +6371,7 @@ var Account = class extends RpcProvider2 {
   async getUniversalSuggestedFee(version, { type, payload }, details) {
     let maxFee = 0;
     let resourceBounds = estimateFeeToBounds(ZERO);
-    if (version === "0x3" /* V3 */) {
+    if (version === api_exports.ETransactionVersion.V3) {
       resourceBounds = details.resourceBounds ?? (await this.getSuggestedFee({ type, payload }, details)).resourceBounds;
     } else {
       maxFee = details.maxFee ?? (await this.getSuggestedFee({ type, payload }, details)).suggestedMaxFee;
@@ -6520,7 +6424,7 @@ var Account = class extends RpcProvider2 {
   async buildDeclarePayload(payload, details) {
     const { classHash, contract, compiledClassHash } = extractContractHashes(payload);
     const compressedCompiledContract = parseContract(contract);
-    if (typeof compiledClassHash === "undefined" && (details.version === "0x100000000000000000000000000000003" /* F3 */ || details.version === "0x3" /* V3 */)) {
+    if (typeof compiledClassHash === "undefined" && (details.version === api_exports.ETransactionVersion3.F3 || details.version === api_exports.ETransactionVersion3.V3)) {
       throw Error("V3 Transaction work with Cairo1 Contracts and require compiledClassHash");
     }
     const signature = !details.skipValidate ? await this.signer.signDeclareTransaction({
@@ -6673,7 +6577,6 @@ var AccountInterface = class extends ProviderInterface {
 var connect_exports = {};
 __export(connect_exports, {
   addDeclareTransaction: () => addDeclareTransaction,
-  addDeployAccountTransaction: () => addDeployAccountTransaction,
   addInvokeTransaction: () => addInvokeTransaction,
   addStarknetChain: () => addStarknetChain,
   deploymentData: () => deploymentData,
@@ -6687,11 +6590,11 @@ __export(connect_exports, {
   switchStarknetChain: () => switchStarknetChain,
   watchAsset: () => watchAsset
 });
-function requestAccounts(swo, silentMode = false) {
+function requestAccounts(swo, silent_mode = false) {
   return swo.request({
     type: "wallet_requestAccounts",
     params: {
-      silentMode
+      silent_mode
     }
   });
 }
@@ -6726,30 +6629,24 @@ function deploymentData(swo) {
 }
 function addInvokeTransaction(swo, params) {
   return swo.request({
-    type: "starknet_addInvokeTransaction",
+    type: "wallet_addInvokeTransaction",
     params
   });
 }
 function addDeclareTransaction(swo, params) {
   return swo.request({
-    type: "starknet_addDeclareTransaction",
-    params
-  });
-}
-function addDeployAccountTransaction(swo, params) {
-  return swo.request({
-    type: "starknet_addDeployAccountTransaction",
+    type: "wallet_addDeclareTransaction",
     params
   });
 }
 function signMessage(swo, typedData) {
   return swo.request({
-    type: "starknet_signTypedData",
+    type: "wallet_signTypedData",
     params: typedData
   });
 }
 function supportedSpecs(swo) {
-  return swo.request({ type: "starknet_supportedSpecs" });
+  return swo.request({ type: "wallet_supportedSpecs" });
 }
 function onAccountChange(swo, callback) {
   swo.on("accountsChanged", callback);
@@ -6778,7 +6675,7 @@ var WalletAccount = class extends Account {
     walletProvider.request({
       type: "wallet_requestAccounts",
       params: {
-        silentMode: false
+        silent_mode: false
       }
     }).then((res) => {
       this.address = res[0].toLowerCase();
@@ -6819,7 +6716,7 @@ var WalletAccount = class extends Account {
       const { contractAddress, entrypoint, calldata } = it;
       return {
         contract_address: contractAddress,
-        entrypoint,
+        entry_point: entrypoint,
         calldata
       };
     });
@@ -6852,14 +6749,6 @@ var WalletAccount = class extends Account {
       contract_address: addresses
     };
   }
-  deployAccount(payload) {
-    const params = {
-      contract_address_salt: payload.addressSalt?.toString() || "0",
-      constructor_calldata: payload.constructorCalldata ? CallData.compile(payload.constructorCalldata) : [],
-      class_hash: payload.classHash
-    };
-    return addDeployAccountTransaction(this.walletProvider, params);
-  }
   signMessage(typedData) {
     return signMessage(this.walletProvider, typedData);
   }
@@ -7395,6 +7284,7 @@ var number = num_exports;
   merkle,
   num,
   number,
+  parseCalldataField,
   parseUDCEvent,
   provider,
   selector,