starknet 6.13.0 → 6.14.0

package/dist/index.js

@@ -197,76 +197,65 @@ var errors_exports = {};
 var components_exports = {};
 
 // src/types/api/rpcspec_0_6/nonspec.ts
-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__ */ ((ESimulationFlag2) => {
-  ESimulationFlag2["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-  ESimulationFlag2["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
-  return ESimulationFlag2;
-})(ESimulationFlag || {});
-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__ */ ((ETransactionFinalityStatus2) => {
-  ETransactionFinalityStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  ETransactionFinalityStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  return ETransactionFinalityStatus2;
-})(ETransactionFinalityStatus || {});
-var ETransactionExecutionStatus = /* @__PURE__ */ ((ETransactionExecutionStatus2) => {
-  ETransactionExecutionStatus2["SUCCEEDED"] = "SUCCEEDED";
-  ETransactionExecutionStatus2["REVERTED"] = "REVERTED";
-  return ETransactionExecutionStatus2;
-})(ETransactionExecutionStatus || {});
-var EBlockTag = /* @__PURE__ */ ((EBlockTag2) => {
-  EBlockTag2["PENDING"] = "pending";
-  EBlockTag2["LATEST"] = "latest";
-  return EBlockTag2;
-})(EBlockTag || {});
-var EDataAvailabilityMode = /* @__PURE__ */ ((EDataAvailabilityMode3) => {
-  EDataAvailabilityMode3["L1"] = "L1";
-  EDataAvailabilityMode3["L2"] = "L2";
-  return EDataAvailabilityMode3;
-})(EDataAvailabilityMode || {});
-var EDAMode = /* @__PURE__ */ ((EDAMode4) => {
-  EDAMode4[EDAMode4["L1"] = 0] = "L1";
-  EDAMode4[EDAMode4["L2"] = 1] = "L2";
-  return EDAMode4;
-})(EDAMode || {});
-var ETransactionVersion = /* @__PURE__ */ ((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__ */ ((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__ */ ((ETransactionVersion37) => {
-  ETransactionVersion37["V3"] = "0x3";
-  ETransactionVersion37["F3"] = "0x100000000000000000000000000000003";
-  return ETransactionVersion37;
-})(ETransactionVersion3 || {});
+var ETransactionType = {
+  DECLARE: "DECLARE",
+  DEPLOY: "DEPLOY",
+  DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
+  INVOKE: "INVOKE",
+  L1_HANDLER: "L1_HANDLER"
+};
+var ESimulationFlag = {
+  SKIP_VALIDATE: "SKIP_VALIDATE",
+  SKIP_FEE_CHARGE: "SKIP_FEE_CHARGE"
+};
+var ETransactionStatus = {
+  RECEIVED: "RECEIVED",
+  REJECTED: "REJECTED",
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+};
+var ETransactionFinalityStatus = {
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+};
+var ETransactionExecutionStatus = {
+  SUCCEEDED: "SUCCEEDED",
+  REVERTED: "REVERTED"
+};
+var EBlockTag = {
+  PENDING: "pending",
+  LATEST: "latest"
+};
+var EDataAvailabilityMode = {
+  L1: "L1",
+  L2: "L2"
+};
+var EDAMode = {
+  L1: 0,
+  L2: 1
+};
+var ETransactionVersion = {
+  V0: "0x0",
+  V1: "0x1",
+  V2: "0x2",
+  V3: "0x3",
+  F0: "0x100000000000000000000000000000000",
+  F1: "0x100000000000000000000000000000001",
+  F2: "0x100000000000000000000000000000002",
+  F3: "0x100000000000000000000000000000003"
+};
+var ETransactionVersion2 = {
+  V0: "0x0",
+  V1: "0x1",
+  V2: "0x2",
+  F0: "0x100000000000000000000000000000000",
+  F1: "0x100000000000000000000000000000001",
+  F2: "0x100000000000000000000000000000002"
+};
+var ETransactionVersion3 = {
+  V3: "0x3",
+  F3: "0x100000000000000000000000000000003"
+};
 
 // src/types/api/index.ts
 var RPCSPEC07 = __toESM(require("starknet-types-07"));
@@ -483,79 +472,71 @@ __export(types_exports, {
 });
 
 // src/types/calldata.ts
-var ValidateType = /* @__PURE__ */ ((ValidateType2) => {
-  ValidateType2["DEPLOY"] = "DEPLOY";
-  ValidateType2["CALL"] = "CALL";
-  ValidateType2["INVOKE"] = "INVOKE";
-  return ValidateType2;
-})(ValidateType || {});
-var Uint = /* @__PURE__ */ ((Uint2) => {
-  Uint2["u8"] = "core::integer::u8";
-  Uint2["u16"] = "core::integer::u16";
-  Uint2["u32"] = "core::integer::u32";
-  Uint2["u64"] = "core::integer::u64";
-  Uint2["u128"] = "core::integer::u128";
-  Uint2["u256"] = "core::integer::u256";
-  Uint2["u512"] = "core::integer::u512";
-  return Uint2;
-})(Uint || {});
-var Literal = /* @__PURE__ */ ((Literal2) => {
-  Literal2["ClassHash"] = "core::starknet::class_hash::ClassHash";
-  Literal2["ContractAddress"] = "core::starknet::contract_address::ContractAddress";
-  Literal2["Secp256k1Point"] = "core::starknet::secp256k1::Secp256k1Point";
-  return Literal2;
-})(Literal || {});
+var ValidateType = {
+  DEPLOY: "DEPLOY",
+  CALL: "CALL",
+  INVOKE: "INVOKE"
+};
+var Uint = {
+  u8: "core::integer::u8",
+  u16: "core::integer::u16",
+  u32: "core::integer::u32",
+  u64: "core::integer::u64",
+  u128: "core::integer::u128",
+  u256: "core::integer::u256",
+  // This one is struct
+  u512: "core::integer::u512"
+  // This one is struct
+};
+var Literal = {
+  ClassHash: "core::starknet::class_hash::ClassHash",
+  ContractAddress: "core::starknet::contract_address::ContractAddress",
+  Secp256k1Point: "core::starknet::secp256k1::Secp256k1Point"
+};
 
 // src/types/lib/contract/index.ts
-var EntryPointType = /* @__PURE__ */ ((EntryPointType2) => {
-  EntryPointType2["EXTERNAL"] = "EXTERNAL";
-  EntryPointType2["L1_HANDLER"] = "L1_HANDLER";
-  EntryPointType2["CONSTRUCTOR"] = "CONSTRUCTOR";
-  return EntryPointType2;
-})(EntryPointType || {});
+var EntryPointType = {
+  EXTERNAL: "EXTERNAL",
+  L1_HANDLER: "L1_HANDLER",
+  CONSTRUCTOR: "CONSTRUCTOR"
+};
 
 // src/types/lib/index.ts
-var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
-  TransactionType2["DECLARE"] = "DECLARE";
-  TransactionType2["DEPLOY"] = "DEPLOY";
-  TransactionType2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-  TransactionType2["INVOKE"] = "INVOKE_FUNCTION";
-  return TransactionType2;
-})(TransactionType || {});
-var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
-  TransactionStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
-  TransactionStatus2["RECEIVED"] = "RECEIVED";
-  TransactionStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  TransactionStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  TransactionStatus2["REJECTED"] = "REJECTED";
-  TransactionStatus2["REVERTED"] = "REVERTED";
-  return TransactionStatus2;
-})(TransactionStatus || {});
-var TransactionFinalityStatus = /* @__PURE__ */ ((TransactionFinalityStatus2) => {
-  TransactionFinalityStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
-  TransactionFinalityStatus2["RECEIVED"] = "RECEIVED";
-  TransactionFinalityStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  TransactionFinalityStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  return TransactionFinalityStatus2;
-})(TransactionFinalityStatus || {});
-var TransactionExecutionStatus = /* @__PURE__ */ ((TransactionExecutionStatus2) => {
-  TransactionExecutionStatus2["REJECTED"] = "REJECTED";
-  TransactionExecutionStatus2["REVERTED"] = "REVERTED";
-  TransactionExecutionStatus2["SUCCEEDED"] = "SUCCEEDED";
-  return TransactionExecutionStatus2;
-})(TransactionExecutionStatus || {});
-var BlockStatus = /* @__PURE__ */ ((BlockStatus2) => {
-  BlockStatus2["PENDING"] = "PENDING";
-  BlockStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  BlockStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  BlockStatus2["REJECTED"] = "REJECTED";
-  return BlockStatus2;
-})(BlockStatus || {});
-var BlockTag = /* @__PURE__ */ ((BlockTag2) => {
-  BlockTag2["PENDING"] = "pending";
-  BlockTag2["LATEST"] = "latest";
-  return BlockTag2;
-})(BlockTag || {});
+var TransactionType = {
+  DECLARE: "DECLARE",
+  DEPLOY: "DEPLOY",
+  DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
+  INVOKE: "INVOKE_FUNCTION"
+};
+var TransactionStatus = {
+  NOT_RECEIVED: "NOT_RECEIVED",
+  RECEIVED: "RECEIVED",
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1",
+  REJECTED: "REJECTED",
+  REVERTED: "REVERTED"
+};
+var TransactionFinalityStatus = {
+  NOT_RECEIVED: "NOT_RECEIVED",
+  RECEIVED: "RECEIVED",
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+};
+var TransactionExecutionStatus = {
+  REJECTED: "REJECTED",
+  REVERTED: "REVERTED",
+  SUCCEEDED: "SUCCEEDED"
+};
+var BlockStatus = {
+  PENDING: "PENDING",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1",
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  REJECTED: "REJECTED"
+};
+var BlockTag = {
+  PENDING: "pending",
+  LATEST: "latest"
+};
 
 // src/types/typedData.ts
 var import_starknet_types_07 = require("starknet-types-07");
@@ -1366,19 +1347,18 @@ var CairoCustomEnum = class {
 };
 
 // src/utils/calldata/enum/CairoOption.ts
-var CairoOptionVariant = /* @__PURE__ */ ((CairoOptionVariant2) => {
-  CairoOptionVariant2[CairoOptionVariant2["Some"] = 0] = "Some";
-  CairoOptionVariant2[CairoOptionVariant2["None"] = 1] = "None";
-  return CairoOptionVariant2;
-})(CairoOptionVariant || {});
+var CairoOptionVariant = {
+  Some: 0,
+  None: 1
+};
 var CairoOption = class {
   Some;
   None;
   constructor(variant, someContent) {
-    if (!(variant in CairoOptionVariant)) {
+    if (!(variant in Object.values(CairoOptionVariant))) {
       throw new Error("Wrong variant : should be CairoOptionVariant.Some or .None.");
     }
-    if (variant === 0 /* Some */) {
+    if (variant === CairoOptionVariant.Some) {
       if (typeof someContent === "undefined") {
         throw new Error(
           'The creation of a Cairo Option with "Some" variant needs a content as input.'
@@ -1419,19 +1399,18 @@ var CairoOption = class {
 };
 
 // src/utils/calldata/enum/CairoResult.ts
-var CairoResultVariant = /* @__PURE__ */ ((CairoResultVariant2) => {
-  CairoResultVariant2[CairoResultVariant2["Ok"] = 0] = "Ok";
-  CairoResultVariant2[CairoResultVariant2["Err"] = 1] = "Err";
-  return CairoResultVariant2;
-})(CairoResultVariant || {});
+var CairoResultVariant = {
+  Ok: 0,
+  Err: 1
+};
 var CairoResult = class {
   Ok;
   Err;
   constructor(variant, resultContent) {
-    if (!(variant in CairoResultVariant)) {
+    if (!(variant in Object.values(CairoResultVariant))) {
       throw new Error("Wrong variant : should be CairoResultVariant.Ok or .Err.");
     }
-    if (variant === 0 /* Ok */) {
+    if (variant === CairoResultVariant.Ok) {
       this.Ok = resultContent;
       this.Err = void 0;
     } else {
@@ -1818,12 +1797,12 @@ function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
       );
       if (unorderedResult.isOk()) {
         return new CairoResult(
-          0 /* Ok */,
+          CairoResultVariant.Ok,
           orderInput(unorderedObject2.unwrap(), resultOkType)
         );
       }
       return new CairoResult(
-        1 /* Err */,
+        CairoResultVariant.Err,
         orderInput(unorderedObject2.unwrap(), resultErrType)
       );
     }
@@ -1835,11 +1814,11 @@ function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
       );
       if (unorderedOption.isSome()) {
         return new CairoOption(
-          0 /* Some */,
+          CairoOptionVariant.Some,
           orderInput(unorderedOption.unwrap(), resultSomeType)
         );
       }
-      return new CairoOption(1 /* None */, {});
+      return new CairoOption(CairoOptionVariant.None, {});
     }
     const unorderedCustomEnum = unorderedObject2;
     const variants = Object.entries(unorderedCustomEnum.variant);
@@ -1974,7 +1953,7 @@ function parseCalldataValue(element, type, structs, enums) {
         }
         const typeVariantSome = listTypeVariant2.type;
         if (typeVariantSome === "()") {
-          return 0 /* Some */.toString();
+          return CairoOptionVariant.Some.toString();
         }
         const parsedParameter2 = parseCalldataValue(
           myOption.unwrap(),
@@ -1983,11 +1962,11 @@ function parseCalldataValue(element, type, structs, enums) {
           enums
         );
         if (Array.isArray(parsedParameter2)) {
-          return [0 /* Some */.toString(), ...parsedParameter2];
+          return [CairoOptionVariant.Some.toString(), ...parsedParameter2];
         }
-        return [0 /* Some */.toString(), parsedParameter2];
+        return [CairoOptionVariant.Some.toString(), parsedParameter2];
       }
-      return 1 /* None */.toString();
+      return CairoOptionVariant.None.toString();
     }
     if (isTypeResult(type)) {
       const myResult = element;
@@ -1998,7 +1977,7 @@ function parseCalldataValue(element, type, structs, enums) {
         }
         const typeVariantOk = listTypeVariant3.type;
         if (typeVariantOk === "()") {
-          return 0 /* Ok */.toString();
+          return CairoResultVariant.Ok.toString();
         }
         const parsedParameter3 = parseCalldataValue(
           myResult.unwrap(),
@@ -2007,9 +1986,9 @@ function parseCalldataValue(element, type, structs, enums) {
           enums
         );
         if (Array.isArray(parsedParameter3)) {
-          return [0 /* Ok */.toString(), ...parsedParameter3];
+          return [CairoResultVariant.Ok.toString(), ...parsedParameter3];
         }
-        return [0 /* Ok */.toString(), parsedParameter3];
+        return [CairoResultVariant.Ok.toString(), parsedParameter3];
       }
       const listTypeVariant2 = variants.find((variant) => variant.name === "Err");
       if (typeof listTypeVariant2 === "undefined") {
@@ -2017,13 +1996,13 @@ function parseCalldataValue(element, type, structs, enums) {
       }
       const typeVariantErr = listTypeVariant2.type;
       if (typeVariantErr === "()") {
-        return 1 /* Err */.toString();
+        return CairoResultVariant.Err.toString();
       }
       const parsedParameter2 = parseCalldataValue(myResult.unwrap(), typeVariantErr, structs, enums);
       if (Array.isArray(parsedParameter2)) {
-        return [1 /* Err */.toString(), ...parsedParameter2];
+        return [CairoResultVariant.Err.toString(), ...parsedParameter2];
       }
-      return [1 /* Err */.toString(), parsedParameter2];
+      return [CairoResultVariant.Err.toString(), parsedParameter2];
     }
     const myEnum = element;
     const activeVariant = myEnum.activeVariant();
@@ -2188,12 +2167,12 @@ function parseResponseValue(responseIterator, element, structs, enums) {
       return acc;
     }, {});
     if (element.type.startsWith("core::option::Option")) {
-      const content = variantNum === 0 /* Some */ ? rawEnum.Some : void 0;
+      const content = variantNum === CairoOptionVariant.Some ? rawEnum.Some : void 0;
       return new CairoOption(variantNum, content);
     }
     if (element.type.startsWith("core::result::Result")) {
       let content;
-      if (variantNum === 0 /* Ok */) {
+      if (variantNum === CairoResultVariant.Ok) {
         content = rawEnum.Ok;
       } else {
         content = rawEnum.Err;
@@ -2298,70 +2277,70 @@ var validateUint = (parameter, input) => {
   );
   let param;
   switch (input.type) {
-    case "core::integer::u256" /* u256 */:
+    case Uint.u256:
       param = new CairoUint256(parameter).toBigInt();
       break;
-    case "core::integer::u512" /* u512 */:
+    case Uint.u512:
       param = new CairoUint512(parameter).toBigInt();
       break;
     default:
       param = toBigInt(parameter);
   }
   switch (input.type) {
-    case "core::integer::u8" /* u8 */:
+    case Uint.u8:
       assert(
         param >= 0n && param <= 255n,
         `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
       );
       break;
-    case "core::integer::u16" /* u16 */:
+    case Uint.u16:
       assert(
         param >= 0n && param <= 65535n,
         `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
       );
       break;
-    case "core::integer::u32" /* u32 */:
+    case Uint.u32:
       assert(
         param >= 0n && param <= 4294967295n,
         `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
       );
       break;
-    case "core::integer::u64" /* u64 */:
+    case Uint.u64:
       assert(
         param >= 0n && param <= 2n ** 64n - 1n,
         `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^64-1]`
       );
       break;
-    case "core::integer::u128" /* u128 */:
+    case Uint.u128:
       assert(
         param >= 0n && param <= 2n ** 128n - 1n,
         `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^128-1]`
       );
       break;
-    case "core::integer::u256" /* u256 */:
+    case Uint.u256:
       assert(
         param >= 0n && param <= 2n ** 256n - 1n,
         `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
       );
       break;
-    case "core::integer::u512" /* u512 */:
+    case Uint.u512:
       assert(CairoUint512.is(param), `Validate: arg ${input.name} is ${input.type} 0 - 2^512-1`);
       break;
-    case "core::starknet::class_hash::ClassHash" /* ClassHash */:
+    case Literal.ClassHash:
       assert(
         // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1670
         param >= 0n && param <= 2n ** 252n - 1n,
         `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`
       );
       break;
-    case "core::starknet::contract_address::ContractAddress" /* ContractAddress */:
+    case Literal.ContractAddress:
       assert(
         // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1245
         param >= 0n && param <= 2n ** 252n - 1n,
         `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`
       );
       break;
-    case "core::starknet::secp256k1::Secp256k1Point" /* Secp256k1Point */: {
+    case Literal.Secp256k1Point: {
       assert(
         param >= 0n && param <= 2n ** 512n - 1n,
         `Validate: arg ${input.name} must be ${input.type} : a 512 bits number.`
@@ -2379,7 +2358,7 @@ var validateBool = (parameter, input) => {
   );
 };
 var validateStruct = (parameter, input, structs) => {
-  if (input.type === "core::integer::u256" /* u256 */ || input.type === "core::integer::u512" /* u512 */) {
+  if (input.type === Uint.u256 || input.type === Uint.u512) {
     validateUint(parameter, input);
     return;
   }
@@ -2488,7 +2467,7 @@ var validateNonZero = (parameter, input) => {
     case isTypeUint(baseType):
       validateUint(parameter, { name: "", type: baseType });
       switch (input.type) {
-        case "core::integer::u256" /* u256 */:
+        case Uint.u256:
           assert(
             new CairoUint256(parameter).toBigInt() > 0,
             "Validate: value 0 is not authorized in NonZero uint256 type."
@@ -2571,19 +2550,19 @@ var CallData = class _CallData {
    * @param args ArgsOrCalldata - arguments that are passed to the method
    */
   validate(type, method, args = []) {
-    if (type !== "DEPLOY" /* DEPLOY */) {
+    if (type !== ValidateType.DEPLOY) {
       const invocableFunctionNames = this.abi.filter((abi) => {
         if (abi.type !== "function") return false;
         const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
-        return type === "INVOKE" /* INVOKE */ ? !isView : isView;
+        return type === ValidateType.INVOKE ? !isView : isView;
       }).map((abi) => abi.name);
       assert(
         invocableFunctionNames.includes(method),
-        `${type === "INVOKE" /* INVOKE */ ? "invocable" : "viewable"} method not found in abi`
+        `${type === ValidateType.INVOKE ? "invocable" : "viewable"} method not found in abi`
       );
     }
     const abiMethod = this.abi.find(
-      (abi) => type === "DEPLOY" /* DEPLOY */ ? abi.name === method && abi.type === "constructor" : abi.name === method && abi.type === "function"
+      (abi) => type === ValidateType.DEPLOY ? abi.name === method && abi.type === "constructor" : abi.name === method && abi.type === "function"
     );
     if (isNoConstructorValid(method, args, abiMethod)) {
       return;
@@ -2660,14 +2639,14 @@ var CallData = class _CallData {
             const keys = [...Object.getOwnPropertyNames(value), ...methodsKeys];
             if (keys.includes("isSome") && keys.includes("isNone")) {
               const myOption = value;
-              const variantNb = myOption.isSome() ? 0 /* Some */ : 1 /* None */;
+              const variantNb = myOption.isSome() ? CairoOptionVariant.Some : CairoOptionVariant.None;
               if (myOption.isSome())
                 return getEntries({ 0: variantNb, 1: myOption.unwrap() }, `${prefix}${kk}.`);
               return [[`${prefix}${kk}`, felt(variantNb)]];
             }
             if (keys.includes("isOk") && keys.includes("isErr")) {
               const myResult = value;
-              const variantNb = myResult.isOk() ? 0 /* Ok */ : 1 /* Err */;
+              const variantNb = myResult.isOk() ? CairoResultVariant.Ok : CairoResultVariant.Err;
               return getEntries({ 0: variantNb, 1: myResult.unwrap() }, `${prefix}${kk}.`);
             }
             if (keys.includes("variant") && keys.includes("activeVariant")) {
@@ -3519,7 +3498,7 @@ var Block = class {
     } else if (isNumber(__identifier)) {
       this.number = __identifier;
     } else {
-      this.tag = "pending" /* PENDING */;
+      this.tag = BlockTag.PENDING;
     }
     if (isNumber(this.number) && this.number < 0) {
       throw TypeError(`Block number (${this.number}) can't be negative`);
@@ -3713,7 +3692,7 @@ function getVersionsByType(versionType) {
 // src/channel/rpc_0_6.ts
 var defaultOptions = {
   headers: { "Content-Type": "application/json" },
-  blockIdentifier: "pending" /* PENDING */,
+  blockIdentifier: BlockTag.PENDING,
   retries: 200
 };
 var RpcChannel = class {
@@ -4207,7 +4186,7 @@ var RpcChannel = class {
         account_deployment_data: invocation.accountDeploymentData.map((it) => toHex(it))
       };
     }
-    if (invocation.type === "INVOKE_FUNCTION" /* INVOKE */) {
+    if (invocation.type === TransactionType.INVOKE) {
       return {
         // v0 v1 v3
         type: rpcspec_0_6_exports.ETransactionType.INVOKE,
@@ -4217,7 +4196,7 @@ var RpcChannel = class {
         ...details
       };
     }
-    if (invocation.type === "DECLARE" /* DECLARE */) {
+    if (invocation.type === TransactionType.DECLARE) {
       if (!isSierra(invocation.contract)) {
         return {
           type: invocation.type,
@@ -4240,7 +4219,7 @@ var RpcChannel = class {
         ...details
       };
     }
-    if (invocation.type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */) {
+    if (invocation.type === TransactionType.DEPLOY_ACCOUNT) {
       const { account_deployment_data, ...restDetails } = details;
       return {
         type: invocation.type,
@@ -4262,7 +4241,7 @@ __export(rpc_0_7_exports, {
 });
 var defaultOptions2 = {
   headers: { "Content-Type": "application/json" },
-  blockIdentifier: "pending" /* PENDING */,
+  blockIdentifier: BlockTag.PENDING,
   retries: 200
 };
 var RpcChannel2 = class {
@@ -4775,7 +4754,7 @@ var RpcChannel2 = class {
         account_deployment_data: invocation.accountDeploymentData.map((it) => toHex(it))
       };
     }
-    if (invocation.type === "INVOKE_FUNCTION" /* INVOKE */) {
+    if (invocation.type === TransactionType.INVOKE) {
       return {
         // v0 v1 v3
         type: RPCSPEC07.ETransactionType.INVOKE,
@@ -4785,7 +4764,7 @@ var RpcChannel2 = class {
         ...details
       };
     }
-    if (invocation.type === "DECLARE" /* DECLARE */) {
+    if (invocation.type === TransactionType.DECLARE) {
       if (!isSierra(invocation.contract)) {
         return {
           type: invocation.type,
@@ -4808,7 +4787,7 @@ var RpcChannel2 = class {
         ...details
       };
     }
-    if (invocation.type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */) {
+    if (invocation.type === TransactionType.DEPLOY_ACCOUNT) {
       const { account_deployment_data, ...restDetails } = details;
       return {
         type: invocation.type,
@@ -4937,13 +4916,13 @@ var ReceiptTx = class _ReceiptTx {
     return this.statusReceipt === "error";
   }
   static isSuccess(transactionReceipt) {
-    return transactionReceipt.execution_status === "SUCCEEDED" /* SUCCEEDED */;
+    return transactionReceipt.execution_status === TransactionExecutionStatus.SUCCEEDED;
   }
   static isReverted(transactionReceipt) {
-    return transactionReceipt.execution_status === "REVERTED" /* REVERTED */;
+    return transactionReceipt.execution_status === TransactionExecutionStatus.REVERTED;
   }
   static isRejected(transactionReceipt) {
-    return transactionReceipt.status === "REJECTED" /* REJECTED */;
+    return transactionReceipt.status === TransactionExecutionStatus.REJECTED;
   }
 };
 
@@ -5434,9 +5413,9 @@ var RpcProvider = class {
    * ```
    */
   async waitForBlock(blockIdentifier = "pending", retryInterval = 5e3) {
-    if (blockIdentifier === "latest" /* LATEST */) return;
+    if (blockIdentifier === BlockTag.LATEST) return;
     const currentBlock = await this.getBlockNumber();
-    const targetBlock = blockIdentifier === "pending" /* PENDING */ ? currentBlock + 1 : Number(toHex(blockIdentifier));
+    const targetBlock = blockIdentifier === BlockTag.PENDING ? currentBlock + 1 : Number(toHex(blockIdentifier));
     if (targetBlock <= currentBlock) return;
     const { retries } = this.channel;
     let retriesCount = retries;
@@ -5492,7 +5471,7 @@ var RpcProvider = class {
    * Utility method, same result can be achieved using getBlockWithTxHashes(BlockTag.pending);
    */
   async getPendingTransactions() {
-    const { transactions } = await this.getBlockWithTxHashes("pending" /* PENDING */).then(
+    const { transactions } = await this.getBlockWithTxHashes(BlockTag.PENDING).then(
       this.responseParser.parseGetBlockResponse
     );
     return Promise.all(transactions.map((it) => this.getTransactionByHash(it)));
@@ -5583,7 +5562,7 @@ var RpcProvider = class {
     return this.channel.getEstimateFee(
       [
         {
-          type: "INVOKE_FUNCTION" /* INVOKE */,
+          type: TransactionType.INVOKE,
           ...invocation,
           ...invocationDetails
         }
@@ -5595,7 +5574,7 @@ var RpcProvider = class {
     return this.channel.getEstimateFee(
       [
         {
-          type: "DECLARE" /* DECLARE */,
+          type: TransactionType.DECLARE,
           ...invocation,
           ...details
         }
@@ -5607,7 +5586,7 @@ var RpcProvider = class {
     return this.channel.getEstimateFee(
       [
         {
-          type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
+          type: TransactionType.DEPLOY_ACCOUNT,
           ...invocation,
           ...details
         }
@@ -5730,6 +5709,54 @@ var RpcProvider = class {
     }
     throw Error(`Signature verification Error: ${error}`);
   }
+  /**
+   * Test if class is already declared from ContractClassIdentifier
+   * Helper method using getClass
+   * @param ContractClassIdentifier
+   * @param blockIdentifier
+   */
+  async isClassDeclared(contractClassIdentifier, blockIdentifier) {
+    let classHash;
+    if (!contractClassIdentifier.classHash && "contract" in contractClassIdentifier) {
+      const hashes = extractContractHashes(contractClassIdentifier);
+      classHash = hashes.classHash;
+    } else if (contractClassIdentifier.classHash) {
+      classHash = contractClassIdentifier.classHash;
+    } else {
+      throw Error("contractClassIdentifier type not satisfied");
+    }
+    try {
+      const result = await this.getClass(classHash, blockIdentifier);
+      return result instanceof Object;
+    } catch (error) {
+      if (error instanceof LibraryError) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Build bulk invocations with auto-detect declared class
+   * 1. Test if class is declared if not declare it preventing already declared class error and not declared class errors
+   * 2. Order declarations first
+   * @param invocations
+   */
+  async prepareInvocations(invocations) {
+    const bulk = [];
+    for (const invocation of invocations) {
+      if (invocation.type === TransactionType.DECLARE) {
+        const isDeclared = await this.isClassDeclared(
+          "payload" in invocation ? invocation.payload : invocation
+        );
+        if (!isDeclared) {
+          bulk.unshift(invocation);
+        }
+      } else {
+        bulk.push(invocation);
+      }
+    }
+    return bulk;
+  }
 };
 
 // src/provider/extensions/default.ts
@@ -5833,32 +5860,30 @@ function useEncoded(decoded) {
   }
   return encoded;
 }
-var StarknetIdContract = /* @__PURE__ */ ((StarknetIdContract2) => {
-  StarknetIdContract2["MAINNET"] = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678";
-  StarknetIdContract2["TESTNET_SEPOLIA"] = "0x154bc2e1af9260b9e66af0e9c46fc757ff893b3ff6a85718a810baf1474";
-  return StarknetIdContract2;
-})(StarknetIdContract || {});
+var StarknetIdContract = {
+  MAINNET: "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678",
+  TESTNET_SEPOLIA: "0x154bc2e1af9260b9e66af0e9c46fc757ff893b3ff6a85718a810baf1474"
+};
 function getStarknetIdContract(chainId) {
   switch (chainId) {
     case "0x534e5f4d41494e" /* SN_MAIN */:
-      return "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678" /* MAINNET */;
+      return StarknetIdContract.MAINNET;
     case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
-      return "0x154bc2e1af9260b9e66af0e9c46fc757ff893b3ff6a85718a810baf1474" /* TESTNET_SEPOLIA */;
+      return StarknetIdContract.TESTNET_SEPOLIA;
     default:
       throw new Error("Starknet.id is not yet deployed on this network");
   }
 }
-var StarknetIdIdentityContract = /* @__PURE__ */ ((StarknetIdIdentityContract2) => {
-  StarknetIdIdentityContract2["MAINNET"] = "0x05dbdedc203e92749e2e746e2d40a768d966bd243df04a6b712e222bc040a9af";
-  StarknetIdIdentityContract2["TESTNET_SEPOLIA"] = "0x3697660a0981d734780731949ecb2b4a38d6a58fc41629ed611e8defda";
-  return StarknetIdIdentityContract2;
-})(StarknetIdIdentityContract || {});
+var StarknetIdIdentityContract = {
+  MAINNET: "0x05dbdedc203e92749e2e746e2d40a768d966bd243df04a6b712e222bc040a9af",
+  TESTNET_SEPOLIA: "0x3697660a0981d734780731949ecb2b4a38d6a58fc41629ed611e8defda"
+};
 function getStarknetIdIdentityContract(chainId) {
   switch (chainId) {
     case "0x534e5f4d41494e" /* SN_MAIN */:
-      return "0x05dbdedc203e92749e2e746e2d40a768d966bd243df04a6b712e222bc040a9af" /* MAINNET */;
+      return StarknetIdIdentityContract.MAINNET;
     case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
-      return "0x3697660a0981d734780731949ecb2b4a38d6a58fc41629ed611e8defda" /* TESTNET_SEPOLIA */;
+      return StarknetIdIdentityContract.TESTNET_SEPOLIA;
     default:
       throw new Error("Starknet.id verifier contract is not yet deployed on this network");
   }
@@ -5874,49 +5899,46 @@ function getStarknetIdMulticallContract(chainId) {
       throw new Error("Starknet.id multicall contract is not yet deployed on this network");
   }
 }
-var StarknetIdVerifierContract = /* @__PURE__ */ ((StarknetIdVerifierContract2) => {
-  StarknetIdVerifierContract2["MAINNET"] = "0x07d14dfd8ee95b41fce179170d88ba1f0d5a512e13aeb232f19cfeec0a88f8bf";
-  StarknetIdVerifierContract2["TESTNET_SEPOLIA"] = "0x60B94fEDe525f815AE5E8377A463e121C787cCCf3a36358Aa9B18c12c4D566";
-  return StarknetIdVerifierContract2;
-})(StarknetIdVerifierContract || {});
+var StarknetIdVerifierContract = {
+  MAINNET: "0x07d14dfd8ee95b41fce179170d88ba1f0d5a512e13aeb232f19cfeec0a88f8bf",
+  TESTNET_SEPOLIA: "0x60B94fEDe525f815AE5E8377A463e121C787cCCf3a36358Aa9B18c12c4D566"
+};
 function getStarknetIdVerifierContract(chainId) {
   switch (chainId) {
     case "0x534e5f4d41494e" /* SN_MAIN */:
-      return "0x07d14dfd8ee95b41fce179170d88ba1f0d5a512e13aeb232f19cfeec0a88f8bf" /* MAINNET */;
+      return StarknetIdVerifierContract.MAINNET;
     case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
-      return "0x60B94fEDe525f815AE5E8377A463e121C787cCCf3a36358Aa9B18c12c4D566" /* TESTNET_SEPOLIA */;
+      return StarknetIdVerifierContract.TESTNET_SEPOLIA;
     default:
       throw new Error("Starknet.id verifier contract is not yet deployed on this network");
   }
 }
-var StarknetIdPfpContract = /* @__PURE__ */ ((StarknetIdPfpContract2) => {
-  StarknetIdPfpContract2["MAINNET"] = "0x070aaa20ec4a46da57c932d9fd89ca5e6bb9ca3188d3df361a32306aff7d59c7";
-  StarknetIdPfpContract2["TESTNET_SEPOLIA"] = "0x9e7bdb8dabd02ea8cfc23b1d1c5278e46490f193f87516ed5ff2dfec02";
-  return StarknetIdPfpContract2;
-})(StarknetIdPfpContract || {});
+var StarknetIdPfpContract = {
+  MAINNET: "0x070aaa20ec4a46da57c932d9fd89ca5e6bb9ca3188d3df361a32306aff7d59c7",
+  TESTNET_SEPOLIA: "0x9e7bdb8dabd02ea8cfc23b1d1c5278e46490f193f87516ed5ff2dfec02"
+};
 function getStarknetIdPfpContract(chainId) {
   switch (chainId) {
     case "0x534e5f4d41494e" /* SN_MAIN */:
-      return "0x070aaa20ec4a46da57c932d9fd89ca5e6bb9ca3188d3df361a32306aff7d59c7" /* MAINNET */;
+      return StarknetIdPfpContract.MAINNET;
     case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
-      return "0x9e7bdb8dabd02ea8cfc23b1d1c5278e46490f193f87516ed5ff2dfec02" /* TESTNET_SEPOLIA */;
+      return StarknetIdPfpContract.TESTNET_SEPOLIA;
     default:
       throw new Error(
         "Starknet.id profile picture verifier contract is not yet deployed on this network"
       );
   }
 }
-var StarknetIdPopContract = /* @__PURE__ */ ((StarknetIdPopContract2) => {
-  StarknetIdPopContract2["MAINNET"] = "0x0293eb2ba9862f762bd3036586d5755a782bd22e6f5028320f1d0405fd47bff4";
-  StarknetIdPopContract2["TESTNET_SEPOLIA"] = "0x15ae88ae054caa74090b89025c1595683f12edf7a4ed2ad0274de3e1d4a";
-  return StarknetIdPopContract2;
-})(StarknetIdPopContract || {});
+var StarknetIdPopContract = {
+  MAINNET: "0x0293eb2ba9862f762bd3036586d5755a782bd22e6f5028320f1d0405fd47bff4",
+  TESTNET_SEPOLIA: "0x15ae88ae054caa74090b89025c1595683f12edf7a4ed2ad0274de3e1d4a"
+};
 function getStarknetIdPopContract(chainId) {
   switch (chainId) {
     case "0x534e5f4d41494e" /* SN_MAIN */:
-      return "0x0293eb2ba9862f762bd3036586d5755a782bd22e6f5028320f1d0405fd47bff4" /* MAINNET */;
+      return StarknetIdPopContract.MAINNET;
     case "0x534e5f5345504f4c4941" /* SN_SEPOLIA */:
-      return "0x15ae88ae054caa74090b89025c1595683f12edf7a4ed2ad0274de3e1d4a" /* TESTNET_SEPOLIA */;
+      return StarknetIdPopContract.TESTNET_SEPOLIA;
     default:
       throw new Error(
         "Starknet.id proof of personhood verifier contract is not yet deployed on this network"
@@ -6607,81 +6629,6 @@ function getLedgerPathBuffer(accountId, applicationName) {
   return pathBuff;
 }
 
-// src/utils/outsideExecution.ts
-var outsideExecution_exports = {};
-__export(outsideExecution_exports, {
-  buildExecuteFromOutsideCallData: () => buildExecuteFromOutsideCallData,
-  getOutsideCall: () => getOutsideCall,
-  getTypedData: () => getTypedData
-});
-function getOutsideCall(call) {
-  const callData = call.calldata ?? [];
-  const callDataCompiled = Array.isArray(callData) ? callData : CallData.compile(callData);
-  return {
-    to: call.contractAddress,
-    selector: getSelectorFromName(call.entrypoint),
-    calldata: callDataCompiled
-  };
-}
-function callToTypedData(call, version) {
-  const outsideCall = getOutsideCall(call);
-  if (version === "1") {
-    return {
-      ...outsideCall,
-      calldata_len: outsideCall.calldata.length,
-      calldata: outsideCall.calldata
-    };
-  }
-  return {
-    To: outsideCall.to,
-    Selector: outsideCall.selector,
-    Calldata: outsideCall.calldata
-  };
-}
-function getDomain(chainId, version) {
-  return {
-    name: "Account.execute_from_outside",
-    version,
-    chainId,
-    ...version === "2" ? { revision: "1" } : {}
-  };
-}
-function getTypedData(chainId, options, nonce, myCalls, version) {
-  if (version === "1") {
-    return {
-      types: OutsideExecutionTypesV1,
-      primaryType: "OutsideExecution",
-      domain: getDomain(chainId, version),
-      message: {
-        ...options,
-        nonce,
-        calls_len: myCalls.length,
-        calls: myCalls.map((call) => callToTypedData(call, version))
-      }
-    };
-  }
-  return {
-    types: OutsideExecutionTypesV2,
-    primaryType: "OutsideExecution",
-    domain: getDomain(chainId, version),
-    message: {
-      Caller: options.caller,
-      Nonce: nonce,
-      "Execute After": options.execute_after,
-      "Execute Before": options.execute_before,
-      Calls: myCalls.map((call) => callToTypedData(call, version))
-    }
-  };
-}
-function buildExecuteFromOutsideCallData(outsideTransaction) {
-  const execution2 = outsideTransaction.outsideExecution;
-  const formattedSignature = formatSignature(outsideTransaction.signature);
-  return CallData.compile({
-    outside_execution: execution2,
-    signature: formattedSignature
-  });
-}
-
 // src/utils/events/index.ts
 var events_exports = {};
 __export(events_exports, {
@@ -6821,6 +6768,81 @@ function parseUDCEvent(txReceipt) {
   };
 }
 
+// src/utils/outsideExecution.ts
+var outsideExecution_exports = {};
+__export(outsideExecution_exports, {
+  buildExecuteFromOutsideCallData: () => buildExecuteFromOutsideCallData,
+  getOutsideCall: () => getOutsideCall,
+  getTypedData: () => getTypedData
+});
+function getOutsideCall(call) {
+  const callData = call.calldata ?? [];
+  const callDataCompiled = Array.isArray(callData) ? callData : CallData.compile(callData);
+  return {
+    to: call.contractAddress,
+    selector: getSelectorFromName(call.entrypoint),
+    calldata: callDataCompiled
+  };
+}
+function callToTypedData(call, version) {
+  const outsideCall = getOutsideCall(call);
+  if (version === "1") {
+    return {
+      ...outsideCall,
+      calldata_len: outsideCall.calldata.length,
+      calldata: outsideCall.calldata
+    };
+  }
+  return {
+    To: outsideCall.to,
+    Selector: outsideCall.selector,
+    Calldata: outsideCall.calldata
+  };
+}
+function getDomain(chainId, version) {
+  return {
+    name: "Account.execute_from_outside",
+    version,
+    chainId,
+    ...version === "2" ? { revision: "1" } : {}
+  };
+}
+function getTypedData(chainId, options, nonce, myCalls, version) {
+  if (version === "1") {
+    return {
+      types: OutsideExecutionTypesV1,
+      primaryType: "OutsideExecution",
+      domain: getDomain(chainId, version),
+      message: {
+        ...options,
+        nonce,
+        calls_len: myCalls.length,
+        calls: myCalls.map((call) => callToTypedData(call, version))
+      }
+    };
+  }
+  return {
+    types: OutsideExecutionTypesV2,
+    primaryType: "OutsideExecution",
+    domain: getDomain(chainId, version),
+    message: {
+      Caller: options.caller,
+      Nonce: nonce,
+      "Execute After": options.execute_after,
+      "Execute Before": options.execute_before,
+      Calls: myCalls.map((call) => callToTypedData(call, version))
+    }
+  };
+}
+function buildExecuteFromOutsideCallData(outsideTransaction) {
+  const execution2 = outsideTransaction.outsideExecution;
+  const formattedSignature = formatSignature(outsideTransaction.signature);
+  return CallData.compile({
+    outside_execution: execution2,
+    signature: formattedSignature
+  });
+}
+
 // src/utils/src5.ts
 var src5_exports = {};
 __export(src5_exports, {
@@ -6988,6 +7010,7 @@ var Account = class extends RpcProvider2 {
     return this.estimateInvokeFee(calls, details);
   }
   async estimateFeeBulk(invocations, details = {}) {
+    if (!invocations.length) throw TypeError("Invocations should be non-empty array");
     const { nonce, blockIdentifier, version, skipValidate } = details;
     const accountInvocations = await this.accountInvocationsFactory(invocations, {
       ...v3Details(details),
@@ -7010,6 +7033,7 @@ var Account = class extends RpcProvider2 {
     });
   }
   async simulateTransaction(invocations, details = {}) {
+    if (!invocations.length) throw TypeError("Invocations should be non-empty array");
     const { nonce, blockIdentifier, skipValidate = true, skipExecute, version } = details;
     const accountInvocations = await this.accountInvocationsFactory(invocations, {
       ...v3Details(details),
@@ -7042,7 +7066,7 @@ var Account = class extends RpcProvider2 {
     );
     const estimate = await this.getUniversalSuggestedFee(
       version,
-      { type: "INVOKE_FUNCTION" /* INVOKE */, payload: transactions },
+      { type: TransactionType.INVOKE, payload: transactions },
       {
         ...details,
         version
@@ -7100,7 +7124,7 @@ var Account = class extends RpcProvider2 {
     const estimate = await this.getUniversalSuggestedFee(
       version,
       {
-        type: "DECLARE" /* DECLARE */,
+        type: TransactionType.DECLARE,
         payload: declareContractPayload
       },
       {
@@ -7168,7 +7192,7 @@ var Account = class extends RpcProvider2 {
     const estimate = await this.getUniversalSuggestedFee(
       version,
       {
-        type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
+        type: TransactionType.DEPLOY_ACCOUNT,
         payload: {
           classHash,
           constructorCalldata: compiledCalldata,
@@ -7410,16 +7434,16 @@ var Account = class extends RpcProvider2 {
   async getSuggestedFee({ type, payload }, details) {
     let feeEstimate;
     switch (type) {
-      case "INVOKE_FUNCTION" /* INVOKE */:
+      case TransactionType.INVOKE:
         feeEstimate = await this.estimateInvokeFee(payload, details);
         break;
-      case "DECLARE" /* DECLARE */:
+      case TransactionType.DECLARE:
         feeEstimate = await this.estimateDeclareFee(payload, details);
         break;
-      case "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */:
+      case TransactionType.DEPLOY_ACCOUNT:
         feeEstimate = await this.estimateAccountDeployFee(payload, details);
         break;
-      case "DEPLOY" /* DEPLOY */:
+      case TransactionType.DEPLOY:
         feeEstimate = await this.estimateDeployFee(payload, details);
         break;
       default:
@@ -7521,7 +7545,7 @@ var Account = class extends RpcProvider2 {
     const chainId = await this.getChainId();
     const versions = details.versions.map((it) => toTransactionVersion(it));
     const tx0Payload = "payload" in invocations[0] ? invocations[0].payload : invocations[0];
-    const cairoVersion = invocations[0].type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */ ? await this.getCairoVersion(tx0Payload.classHash) : await this.getCairoVersion();
+    const cairoVersion = invocations[0].type === TransactionType.DEPLOY_ACCOUNT ? await this.getCairoVersion(tx0Payload.classHash) : await this.getCairoVersion();
     return Promise.all(
       [].concat(invocations).map(async (transaction, index) => {
         const txPayload = "payload" in transaction ? transaction.payload : transaction;
@@ -7541,7 +7565,7 @@ var Account = class extends RpcProvider2 {
           blockIdentifier,
           version: ""
         };
-        if (transaction.type === "INVOKE_FUNCTION" /* INVOKE */) {
+        if (transaction.type === TransactionType.INVOKE) {
           const versionX = reduceV2(versions[1]);
           signerDetails.version = versionX;
           common.version = versionX;
@@ -7554,7 +7578,7 @@ var Account = class extends RpcProvider2 {
             ...payload
           };
         }
-        if (transaction.type === "DEPLOY" /* DEPLOY */) {
+        if (transaction.type === TransactionType.DEPLOY) {
           const versionX = reduceV2(versions[1]);
           signerDetails.version = versionX;
           common.version = versionX;
@@ -7563,10 +7587,10 @@ var Account = class extends RpcProvider2 {
           return {
             ...common,
             ...payload,
-            type: "INVOKE_FUNCTION" /* INVOKE */
+            type: TransactionType.INVOKE
           };
         }
-        if (transaction.type === "DECLARE" /* DECLARE */) {
+        if (transaction.type === TransactionType.DECLARE) {
           const versionX = !isSierra(txPayload.contract) ? versions[0] : versions[1];
           signerDetails.version = versionX;
           common.version = versionX;
@@ -7576,7 +7600,7 @@ var Account = class extends RpcProvider2 {
             ...payload
           };
         }
-        if (transaction.type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */) {
+        if (transaction.type === TransactionType.DEPLOY_ACCOUNT) {
           const versionX = reduceV2(versions[1]);
           signerDetails.version = versionX;
           common.version = versionX;
@@ -7929,7 +7953,7 @@ var Contract = class {
     assert(this.address !== null, "contract is not connected to an address");
     const calldata = getCalldata(args, () => {
       if (parseRequest) {
-        this.callData.validate("CALL" /* CALL */, method, args);
+        this.callData.validate(ValidateType.CALL, method, args);
         return this.callData.compile(method, args);
       }
       console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
@@ -7956,7 +7980,7 @@ var Contract = class {
     assert(this.address !== null, "contract is not connected to an address");
     const calldata = getCalldata(args, () => {
       if (parseRequest) {
-        this.callData.validate("INVOKE" /* INVOKE */, method, args);
+        this.callData.validate(ValidateType.INVOKE, method, args);
         return this.callData.compile(method, args);
       }
       console.warn("Invoke skipped parsing but provided rawArgs, possible malfunction request");
@@ -7988,7 +8012,7 @@ var Contract = class {
   async estimate(method, args = []) {
     assert(this.address !== null, "contract is not connected to an address");
     if (!getCalldata(args, () => false)) {
-      this.callData.validate("INVOKE" /* INVOKE */, method, args);
+      this.callData.validate(ValidateType.INVOKE, method, args);
     }
     const invocation = this.populate(method, args);
     if ("estimateInvokeFee" in this.providerOrAccount) {
@@ -8070,7 +8094,7 @@ var ContractFactory = class {
     const { args: param, options = { parseRequest: true } } = splitArgsAndOptions(args);
     const constructorCalldata = getCalldata(param, () => {
       if (options.parseRequest) {
-        this.CallData.validate("DEPLOY" /* DEPLOY */, "constructor", param);
+        this.CallData.validate(ValidateType.DEPLOY, "constructor", param);
         return this.CallData.compile("constructor", param);
       }
       console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");