starknet 6.13.0 → 6.14.0

package/dist/index.global.js

@@ -12827,76 +12827,65 @@ var starknet = (() => {
   var components_exports = {};
 
   // src/types/api/rpcspec_0_6/nonspec.ts
-  var ETransactionType = /* @__PURE__ */ ((ETransactionType3) => {
-    ETransactionType3["DECLARE"] = "DECLARE";
-    ETransactionType3["DEPLOY"] = "DEPLOY";
-    ETransactionType3["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-    ETransactionType3["INVOKE"] = "INVOKE";
-    ETransactionType3["L1_HANDLER"] = "L1_HANDLER";
-    return ETransactionType3;
-  })(ETransactionType || {});
-  var ESimulationFlag = /* @__PURE__ */ ((ESimulationFlag3) => {
-    ESimulationFlag3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-    ESimulationFlag3["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
-    return ESimulationFlag3;
-  })(ESimulationFlag || {});
-  var ETransactionStatus = /* @__PURE__ */ ((ETransactionStatus3) => {
-    ETransactionStatus3["RECEIVED"] = "RECEIVED";
-    ETransactionStatus3["REJECTED"] = "REJECTED";
-    ETransactionStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    ETransactionStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    return ETransactionStatus3;
-  })(ETransactionStatus || {});
-  var ETransactionFinalityStatus = /* @__PURE__ */ ((ETransactionFinalityStatus3) => {
-    ETransactionFinalityStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    ETransactionFinalityStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    return ETransactionFinalityStatus3;
-  })(ETransactionFinalityStatus || {});
-  var ETransactionExecutionStatus = /* @__PURE__ */ ((ETransactionExecutionStatus3) => {
-    ETransactionExecutionStatus3["SUCCEEDED"] = "SUCCEEDED";
-    ETransactionExecutionStatus3["REVERTED"] = "REVERTED";
-    return ETransactionExecutionStatus3;
-  })(ETransactionExecutionStatus || {});
-  var EBlockTag = /* @__PURE__ */ ((EBlockTag3) => {
-    EBlockTag3["PENDING"] = "pending";
-    EBlockTag3["LATEST"] = "latest";
-    return EBlockTag3;
-  })(EBlockTag || {});
-  var EDataAvailabilityMode = /* @__PURE__ */ ((EDataAvailabilityMode3) => {
-    EDataAvailabilityMode3["L1"] = "L1";
-    EDataAvailabilityMode3["L2"] = "L2";
-    return EDataAvailabilityMode3;
-  })(EDataAvailabilityMode || {});
-  var EDAMode = /* @__PURE__ */ ((EDAMode4) => {
-    EDAMode4[EDAMode4["L1"] = 0] = "L1";
-    EDAMode4[EDAMode4["L2"] = 1] = "L2";
-    return EDAMode4;
-  })(EDAMode || {});
-  var ETransactionVersion = /* @__PURE__ */ ((ETransactionVersion5) => {
-    ETransactionVersion5["V0"] = "0x0";
-    ETransactionVersion5["V1"] = "0x1";
-    ETransactionVersion5["V2"] = "0x2";
-    ETransactionVersion5["V3"] = "0x3";
-    ETransactionVersion5["F0"] = "0x100000000000000000000000000000000";
-    ETransactionVersion5["F1"] = "0x100000000000000000000000000000001";
-    ETransactionVersion5["F2"] = "0x100000000000000000000000000000002";
-    ETransactionVersion5["F3"] = "0x100000000000000000000000000000003";
-    return ETransactionVersion5;
-  })(ETransactionVersion || {});
-  var ETransactionVersion2 = /* @__PURE__ */ ((ETransactionVersion24) => {
-    ETransactionVersion24["V0"] = "0x0";
-    ETransactionVersion24["V1"] = "0x1";
-    ETransactionVersion24["V2"] = "0x2";
-    ETransactionVersion24["F0"] = "0x100000000000000000000000000000000";
-    ETransactionVersion24["F1"] = "0x100000000000000000000000000000001";
-    ETransactionVersion24["F2"] = "0x100000000000000000000000000000002";
-    return ETransactionVersion24;
-  })(ETransactionVersion2 || {});
-  var ETransactionVersion3 = /* @__PURE__ */ ((ETransactionVersion34) => {
-    ETransactionVersion34["V3"] = "0x3";
-    ETransactionVersion34["F3"] = "0x100000000000000000000000000000003";
-    return ETransactionVersion34;
-  })(ETransactionVersion3 || {});
+  var ETransactionType = {
+    DECLARE: "DECLARE",
+    DEPLOY: "DEPLOY",
+    DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
+    INVOKE: "INVOKE",
+    L1_HANDLER: "L1_HANDLER"
+  };
+  var ESimulationFlag = {
+    SKIP_VALIDATE: "SKIP_VALIDATE",
+    SKIP_FEE_CHARGE: "SKIP_FEE_CHARGE"
+  };
+  var ETransactionStatus = {
+    RECEIVED: "RECEIVED",
+    REJECTED: "REJECTED",
+    ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+    ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+  };
+  var ETransactionFinalityStatus = {
+    ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+    ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+  };
+  var ETransactionExecutionStatus = {
+    SUCCEEDED: "SUCCEEDED",
+    REVERTED: "REVERTED"
+  };
+  var EBlockTag = {
+    PENDING: "pending",
+    LATEST: "latest"
+  };
+  var EDataAvailabilityMode = {
+    L1: "L1",
+    L2: "L2"
+  };
+  var EDAMode = {
+    L1: 0,
+    L2: 1
+  };
+  var ETransactionVersion = {
+    V0: "0x0",
+    V1: "0x1",
+    V2: "0x2",
+    V3: "0x3",
+    F0: "0x100000000000000000000000000000000",
+    F1: "0x100000000000000000000000000000001",
+    F2: "0x100000000000000000000000000000002",
+    F3: "0x100000000000000000000000000000003"
+  };
+  var ETransactionVersion2 = {
+    V0: "0x0",
+    V1: "0x1",
+    V2: "0x2",
+    F0: "0x100000000000000000000000000000000",
+    F1: "0x100000000000000000000000000000001",
+    F2: "0x100000000000000000000000000000002"
+  };
+  var ETransactionVersion3 = {
+    V3: "0x3",
+    F3: "0x100000000000000000000000000000003"
+  };
 
   // node_modules/starknet-types-07/dist/esm/index.js
   var esm_exports = {};
@@ -13392,79 +13381,71 @@ var starknet = (() => {
   });
 
   // src/types/calldata.ts
-  var ValidateType = /* @__PURE__ */ ((ValidateType2) => {
-    ValidateType2["DEPLOY"] = "DEPLOY";
-    ValidateType2["CALL"] = "CALL";
-    ValidateType2["INVOKE"] = "INVOKE";
-    return ValidateType2;
-  })(ValidateType || {});
-  var Uint = /* @__PURE__ */ ((Uint2) => {
-    Uint2["u8"] = "core::integer::u8";
-    Uint2["u16"] = "core::integer::u16";
-    Uint2["u32"] = "core::integer::u32";
-    Uint2["u64"] = "core::integer::u64";
-    Uint2["u128"] = "core::integer::u128";
-    Uint2["u256"] = "core::integer::u256";
-    Uint2["u512"] = "core::integer::u512";
-    return Uint2;
-  })(Uint || {});
-  var Literal = /* @__PURE__ */ ((Literal2) => {
-    Literal2["ClassHash"] = "core::starknet::class_hash::ClassHash";
-    Literal2["ContractAddress"] = "core::starknet::contract_address::ContractAddress";
-    Literal2["Secp256k1Point"] = "core::starknet::secp256k1::Secp256k1Point";
-    return Literal2;
-  })(Literal || {});
+  var ValidateType = {
+    DEPLOY: "DEPLOY",
+    CALL: "CALL",
+    INVOKE: "INVOKE"
+  };
+  var Uint = {
+    u8: "core::integer::u8",
+    u16: "core::integer::u16",
+    u32: "core::integer::u32",
+    u64: "core::integer::u64",
+    u128: "core::integer::u128",
+    u256: "core::integer::u256",
+    // This one is struct
+    u512: "core::integer::u512"
+    // This one is struct
+  };
+  var Literal = {
+    ClassHash: "core::starknet::class_hash::ClassHash",
+    ContractAddress: "core::starknet::contract_address::ContractAddress",
+    Secp256k1Point: "core::starknet::secp256k1::Secp256k1Point"
+  };
 
   // src/types/lib/contract/index.ts
-  var EntryPointType = /* @__PURE__ */ ((EntryPointType2) => {
-    EntryPointType2["EXTERNAL"] = "EXTERNAL";
-    EntryPointType2["L1_HANDLER"] = "L1_HANDLER";
-    EntryPointType2["CONSTRUCTOR"] = "CONSTRUCTOR";
-    return EntryPointType2;
-  })(EntryPointType || {});
+  var EntryPointType = {
+    EXTERNAL: "EXTERNAL",
+    L1_HANDLER: "L1_HANDLER",
+    CONSTRUCTOR: "CONSTRUCTOR"
+  };
 
   // src/types/lib/index.ts
-  var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
-    TransactionType2["DECLARE"] = "DECLARE";
-    TransactionType2["DEPLOY"] = "DEPLOY";
-    TransactionType2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-    TransactionType2["INVOKE"] = "INVOKE_FUNCTION";
-    return TransactionType2;
-  })(TransactionType || {});
-  var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
-    TransactionStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
-    TransactionStatus2["RECEIVED"] = "RECEIVED";
-    TransactionStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    TransactionStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    TransactionStatus2["REJECTED"] = "REJECTED";
-    TransactionStatus2["REVERTED"] = "REVERTED";
-    return TransactionStatus2;
-  })(TransactionStatus || {});
-  var TransactionFinalityStatus = /* @__PURE__ */ ((TransactionFinalityStatus2) => {
-    TransactionFinalityStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
-    TransactionFinalityStatus2["RECEIVED"] = "RECEIVED";
-    TransactionFinalityStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    TransactionFinalityStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    return TransactionFinalityStatus2;
-  })(TransactionFinalityStatus || {});
-  var TransactionExecutionStatus = /* @__PURE__ */ ((TransactionExecutionStatus2) => {
-    TransactionExecutionStatus2["REJECTED"] = "REJECTED";
-    TransactionExecutionStatus2["REVERTED"] = "REVERTED";
-    TransactionExecutionStatus2["SUCCEEDED"] = "SUCCEEDED";
-    return TransactionExecutionStatus2;
-  })(TransactionExecutionStatus || {});
-  var BlockStatus = /* @__PURE__ */ ((BlockStatus2) => {
-    BlockStatus2["PENDING"] = "PENDING";
-    BlockStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    BlockStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    BlockStatus2["REJECTED"] = "REJECTED";
-    return BlockStatus2;
-  })(BlockStatus || {});
-  var BlockTag = /* @__PURE__ */ ((BlockTag2) => {
-    BlockTag2["PENDING"] = "pending";
-    BlockTag2["LATEST"] = "latest";
-    return BlockTag2;
-  })(BlockTag || {});
+  var TransactionType = {
+    DECLARE: "DECLARE",
+    DEPLOY: "DEPLOY",
+    DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
+    INVOKE: "INVOKE_FUNCTION"
+  };
+  var TransactionStatus = {
+    NOT_RECEIVED: "NOT_RECEIVED",
+    RECEIVED: "RECEIVED",
+    ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+    ACCEPTED_ON_L1: "ACCEPTED_ON_L1",
+    REJECTED: "REJECTED",
+    REVERTED: "REVERTED"
+  };
+  var TransactionFinalityStatus = {
+    NOT_RECEIVED: "NOT_RECEIVED",
+    RECEIVED: "RECEIVED",
+    ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+    ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+  };
+  var TransactionExecutionStatus = {
+    REJECTED: "REJECTED",
+    REVERTED: "REVERTED",
+    SUCCEEDED: "SUCCEEDED"
+  };
+  var BlockStatus = {
+    PENDING: "PENDING",
+    ACCEPTED_ON_L1: "ACCEPTED_ON_L1",
+    ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+    REJECTED: "REJECTED"
+  };
+  var BlockTag = {
+    PENDING: "pending",
+    LATEST: "latest"
+  };
 
   // src/types/outsideExecution.ts
   var OutsideExecutionTypesV1 = {
@@ -17370,19 +17351,18 @@ var starknet = (() => {
   };
 
   // src/utils/calldata/enum/CairoOption.ts
-  var CairoOptionVariant = /* @__PURE__ */ ((CairoOptionVariant2) => {
-    CairoOptionVariant2[CairoOptionVariant2["Some"] = 0] = "Some";
-    CairoOptionVariant2[CairoOptionVariant2["None"] = 1] = "None";
-    return CairoOptionVariant2;
-  })(CairoOptionVariant || {});
+  var CairoOptionVariant = {
+    Some: 0,
+    None: 1
+  };
   var CairoOption = class {
     Some;
     None;
     constructor(variant, someContent) {
-      if (!(variant in CairoOptionVariant)) {
+      if (!(variant in Object.values(CairoOptionVariant))) {
         throw new Error("Wrong variant : should be CairoOptionVariant.Some or .None.");
       }
-      if (variant === 0 /* Some */) {
+      if (variant === CairoOptionVariant.Some) {
         if (typeof someContent === "undefined") {
           throw new Error(
             'The creation of a Cairo Option with "Some" variant needs a content as input.'
@@ -17423,19 +17403,18 @@ var starknet = (() => {
   };
 
   // src/utils/calldata/enum/CairoResult.ts
-  var CairoResultVariant = /* @__PURE__ */ ((CairoResultVariant2) => {
-    CairoResultVariant2[CairoResultVariant2["Ok"] = 0] = "Ok";
-    CairoResultVariant2[CairoResultVariant2["Err"] = 1] = "Err";
-    return CairoResultVariant2;
-  })(CairoResultVariant || {});
+  var CairoResultVariant = {
+    Ok: 0,
+    Err: 1
+  };
   var CairoResult = class {
     Ok;
     Err;
     constructor(variant, resultContent) {
-      if (!(variant in CairoResultVariant)) {
+      if (!(variant in Object.values(CairoResultVariant))) {
         throw new Error("Wrong variant : should be CairoResultVariant.Ok or .Err.");
       }
-      if (variant === 0 /* Ok */) {
+      if (variant === CairoResultVariant.Ok) {
         this.Ok = resultContent;
         this.Err = void 0;
       } else {
@@ -17822,12 +17801,12 @@ var starknet = (() => {
         );
         if (unorderedResult.isOk()) {
           return new CairoResult(
-            0 /* Ok */,
+            CairoResultVariant.Ok,
             orderInput(unorderedObject2.unwrap(), resultOkType)
           );
         }
         return new CairoResult(
-          1 /* Err */,
+          CairoResultVariant.Err,
           orderInput(unorderedObject2.unwrap(), resultErrType)
         );
       }
@@ -17839,11 +17818,11 @@ var starknet = (() => {
         );
         if (unorderedOption.isSome()) {
           return new CairoOption(
-            0 /* Some */,
+            CairoOptionVariant.Some,
             orderInput(unorderedOption.unwrap(), resultSomeType)
           );
         }
-        return new CairoOption(1 /* None */, {});
+        return new CairoOption(CairoOptionVariant.None, {});
       }
       const unorderedCustomEnum = unorderedObject2;
       const variants = Object.entries(unorderedCustomEnum.variant);
@@ -17978,7 +17957,7 @@ var starknet = (() => {
           }
           const typeVariantSome = listTypeVariant2.type;
           if (typeVariantSome === "()") {
-            return 0 /* Some */.toString();
+            return CairoOptionVariant.Some.toString();
           }
           const parsedParameter2 = parseCalldataValue(
             myOption.unwrap(),
@@ -17987,11 +17966,11 @@ var starknet = (() => {
             enums
           );
           if (Array.isArray(parsedParameter2)) {
-            return [0 /* Some */.toString(), ...parsedParameter2];
+            return [CairoOptionVariant.Some.toString(), ...parsedParameter2];
           }
-          return [0 /* Some */.toString(), parsedParameter2];
+          return [CairoOptionVariant.Some.toString(), parsedParameter2];
         }
-        return 1 /* None */.toString();
+        return CairoOptionVariant.None.toString();
       }
       if (isTypeResult(type)) {
         const myResult = element;
@@ -18002,7 +17981,7 @@ var starknet = (() => {
           }
           const typeVariantOk = listTypeVariant3.type;
           if (typeVariantOk === "()") {
-            return 0 /* Ok */.toString();
+            return CairoResultVariant.Ok.toString();
           }
           const parsedParameter3 = parseCalldataValue(
             myResult.unwrap(),
@@ -18011,9 +17990,9 @@ var starknet = (() => {
             enums
           );
           if (Array.isArray(parsedParameter3)) {
-            return [0 /* Ok */.toString(), ...parsedParameter3];
+            return [CairoResultVariant.Ok.toString(), ...parsedParameter3];
           }
-          return [0 /* Ok */.toString(), parsedParameter3];
+          return [CairoResultVariant.Ok.toString(), parsedParameter3];
         }
         const listTypeVariant2 = variants.find((variant) => variant.name === "Err");
         if (typeof listTypeVariant2 === "undefined") {
@@ -18021,13 +18000,13 @@ var starknet = (() => {
         }
         const typeVariantErr = listTypeVariant2.type;
         if (typeVariantErr === "()") {
-          return 1 /* Err */.toString();
+          return CairoResultVariant.Err.toString();
         }
         const parsedParameter2 = parseCalldataValue(myResult.unwrap(), typeVariantErr, structs, enums);
         if (Array.isArray(parsedParameter2)) {
-          return [1 /* Err */.toString(), ...parsedParameter2];
+          return [CairoResultVariant.Err.toString(), ...parsedParameter2];
         }
-        return [1 /* Err */.toString(), parsedParameter2];
+        return [CairoResultVariant.Err.toString(), parsedParameter2];
       }
       const myEnum = element;
       const activeVariant = myEnum.activeVariant();
@@ -18192,12 +18171,12 @@ var starknet = (() => {
         return acc;
       }, {});
       if (element.type.startsWith("core::option::Option")) {
-        const content = variantNum === 0 /* Some */ ? rawEnum.Some : void 0;
+        const content = variantNum === CairoOptionVariant.Some ? rawEnum.Some : void 0;
         return new CairoOption(variantNum, content);
       }
       if (element.type.startsWith("core::result::Result")) {
         let content;
-        if (variantNum === 0 /* Ok */) {
+        if (variantNum === CairoResultVariant.Ok) {
           content = rawEnum.Ok;
         } else {
           content = rawEnum.Err;
@@ -18302,70 +18281,70 @@ var starknet = (() => {
     );
     let param;
     switch (input.type) {
-      case "core::integer::u256" /* u256 */:
+      case Uint.u256:
         param = new CairoUint256(parameter).toBigInt();
         break;
-      case "core::integer::u512" /* u512 */:
+      case Uint.u512:
         param = new CairoUint512(parameter).toBigInt();
         break;
       default:
         param = toBigInt(parameter);
     }
     switch (input.type) {
-      case "core::integer::u8" /* u8 */:
+      case Uint.u8:
         assert(
           param >= 0n && param <= 255n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
         );
         break;
-      case "core::integer::u16" /* u16 */:
+      case Uint.u16:
         assert(
           param >= 0n && param <= 65535n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
         );
         break;
-      case "core::integer::u32" /* u32 */:
+      case Uint.u32:
         assert(
           param >= 0n && param <= 4294967295n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
         );
         break;
-      case "core::integer::u64" /* u64 */:
+      case Uint.u64:
         assert(
           param >= 0n && param <= 2n ** 64n - 1n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^64-1]`
         );
         break;
-      case "core::integer::u128" /* u128 */:
+      case Uint.u128:
         assert(
           param >= 0n && param <= 2n ** 128n - 1n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^128-1]`
         );
         break;
-      case "core::integer::u256" /* u256 */:
+      case Uint.u256:
         assert(
           param >= 0n && param <= 2n ** 256n - 1n,
           `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
         );
         break;
-      case "core::integer::u512" /* u512 */:
+      case Uint.u512:
         assert(CairoUint512.is(param), `Validate: arg ${input.name} is ${input.type} 0 - 2^512-1`);
         break;
-      case "core::starknet::class_hash::ClassHash" /* ClassHash */:
+      case Literal.ClassHash:
         assert(
           // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1670
           param >= 0n && param <= 2n ** 252n - 1n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`
         );
         break;
-      case "core::starknet::contract_address::ContractAddress" /* ContractAddress */:
+      case Literal.ContractAddress:
         assert(
           // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1245
           param >= 0n && param <= 2n ** 252n - 1n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`
         );
         break;
-      case "core::starknet::secp256k1::Secp256k1Point" /* Secp256k1Point */: {
+      case Literal.Secp256k1Point: {
         assert(
           param >= 0n && param <= 2n ** 512n - 1n,
           `Validate: arg ${input.name} must be ${input.type} : a 512 bits number.`
@@ -18383,7 +18362,7 @@ var starknet = (() => {
     );
   };
   var validateStruct = (parameter, input, structs) => {
-    if (input.type === "core::integer::u256" /* u256 */ || input.type === "core::integer::u512" /* u512 */) {
+    if (input.type === Uint.u256 || input.type === Uint.u512) {
       validateUint(parameter, input);
       return;
     }
@@ -18492,7 +18471,7 @@ var starknet = (() => {
       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."
@@ -18575,19 +18554,19 @@ var starknet = (() => {
      * @param args ArgsOrCalldata - arguments that are passed to the method
      */
     validate(type, method, args = []) {
-      if (type !== "DEPLOY" /* DEPLOY */) {
+      if (type !== ValidateType.DEPLOY) {
         const invocableFunctionNames = this.abi.filter((abi) => {
           if (abi.type !== "function") return false;
           const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
-          return type === "INVOKE" /* INVOKE */ ? !isView : isView;
+          return type === ValidateType.INVOKE ? !isView : isView;
         }).map((abi) => abi.name);
         assert(
           invocableFunctionNames.includes(method),
-          `${type === "INVOKE" /* INVOKE */ ? "invocable" : "viewable"} method not found in abi`
+          `${type === ValidateType.INVOKE ? "invocable" : "viewable"} method not found in abi`
         );
       }
       const abiMethod = this.abi.find(
-        (abi) => type === "DEPLOY" /* DEPLOY */ ? abi.name === method && abi.type === "constructor" : abi.name === method && abi.type === "function"
+        (abi) => type === ValidateType.DEPLOY ? abi.name === method && abi.type === "constructor" : abi.name === method && abi.type === "function"
       );
       if (isNoConstructorValid(method, args, abiMethod)) {
         return;
@@ -18664,14 +18643,14 @@ var starknet = (() => {
               const keys = [...Object.getOwnPropertyNames(value), ...methodsKeys];
               if (keys.includes("isSome") && keys.includes("isNone")) {
                 const myOption = value;
-                const variantNb = myOption.isSome() ? 0 /* Some */ : 1 /* None */;
+                const variantNb = myOption.isSome() ? CairoOptionVariant.Some : CairoOptionVariant.None;
                 if (myOption.isSome())
                   return getEntries({ 0: variantNb, 1: myOption.unwrap() }, `${prefix}${kk}.`);
                 return [[`${prefix}${kk}`, felt(variantNb)]];
               }
               if (keys.includes("isOk") && keys.includes("isErr")) {
                 const myResult = value;
-                const variantNb = myResult.isOk() ? 0 /* Ok */ : 1 /* Err */;
+                const variantNb = myResult.isOk() ? CairoResultVariant.Ok : CairoResultVariant.Err;
                 return getEntries({ 0: variantNb, 1: myResult.unwrap() }, `${prefix}${kk}.`);
               }
               if (keys.includes("variant") && keys.includes("activeVariant")) {
@@ -23933,7 +23912,7 @@ var starknet = (() => {
       } else if (isNumber2(__identifier)) {
         this.number = __identifier;
       } else {
-        this.tag = "pending" /* PENDING */;
+        this.tag = BlockTag.PENDING;
       }
       if (isNumber2(this.number) && this.number < 0) {
         throw TypeError(`Block number (${this.number}) can't be negative`);
@@ -24127,7 +24106,7 @@ var starknet = (() => {
   // src/channel/rpc_0_6.ts
   var defaultOptions = {
     headers: { "Content-Type": "application/json" },
-    blockIdentifier: "pending" /* PENDING */,
+    blockIdentifier: BlockTag.PENDING,
     retries: 200
   };
   var RpcChannel = class {
@@ -24621,7 +24600,7 @@ var starknet = (() => {
           account_deployment_data: invocation.accountDeploymentData.map((it) => toHex(it))
         };
       }
-      if (invocation.type === "INVOKE_FUNCTION" /* INVOKE */) {
+      if (invocation.type === TransactionType.INVOKE) {
         return {
           // v0 v1 v3
           type: rpcspec_0_6_exports.ETransactionType.INVOKE,
@@ -24631,7 +24610,7 @@ var starknet = (() => {
           ...details
         };
       }
-      if (invocation.type === "DECLARE" /* DECLARE */) {
+      if (invocation.type === TransactionType.DECLARE) {
         if (!isSierra(invocation.contract)) {
           return {
             type: invocation.type,
@@ -24654,7 +24633,7 @@ var starknet = (() => {
           ...details
         };
       }
-      if (invocation.type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */) {
+      if (invocation.type === TransactionType.DEPLOY_ACCOUNT) {
         const { account_deployment_data, ...restDetails } = details;
         return {
           type: invocation.type,
@@ -24676,7 +24655,7 @@ var starknet = (() => {
   });
   var defaultOptions2 = {
     headers: { "Content-Type": "application/json" },
-    blockIdentifier: "pending" /* PENDING */,
+    blockIdentifier: BlockTag.PENDING,
     retries: 200
   };
   var RpcChannel2 = class {
@@ -25189,7 +25168,7 @@ var starknet = (() => {
           account_deployment_data: invocation.accountDeploymentData.map((it) => toHex(it))
         };
       }
-      if (invocation.type === "INVOKE_FUNCTION" /* INVOKE */) {
+      if (invocation.type === TransactionType.INVOKE) {
         return {
           // v0 v1 v3
           type: esm_exports.ETransactionType.INVOKE,
@@ -25199,7 +25178,7 @@ var starknet = (() => {
           ...details
         };
       }
-      if (invocation.type === "DECLARE" /* DECLARE */) {
+      if (invocation.type === TransactionType.DECLARE) {
         if (!isSierra(invocation.contract)) {
           return {
             type: invocation.type,
@@ -25222,7 +25201,7 @@ var starknet = (() => {
           ...details
         };
       }
-      if (invocation.type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */) {
+      if (invocation.type === TransactionType.DEPLOY_ACCOUNT) {
         const { account_deployment_data, ...restDetails } = details;
         return {
           type: invocation.type,
@@ -25351,13 +25330,13 @@ var starknet = (() => {
       return this.statusReceipt === "error";
     }
     static isSuccess(transactionReceipt) {
-      return transactionReceipt.execution_status === "SUCCEEDED" /* SUCCEEDED */;
+      return transactionReceipt.execution_status === TransactionExecutionStatus.SUCCEEDED;
     }
     static isReverted(transactionReceipt) {
-      return transactionReceipt.execution_status === "REVERTED" /* REVERTED */;
+      return transactionReceipt.execution_status === TransactionExecutionStatus.REVERTED;
     }
     static isRejected(transactionReceipt) {
-      return transactionReceipt.status === "REJECTED" /* REJECTED */;
+      return transactionReceipt.status === TransactionExecutionStatus.REJECTED;
     }
   };
 
@@ -25848,9 +25827,9 @@ var starknet = (() => {
      * ```
      */
     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;
@@ -25906,7 +25885,7 @@ var starknet = (() => {
      * 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)));
@@ -25997,7 +25976,7 @@ var starknet = (() => {
       return this.channel.getEstimateFee(
         [
           {
-            type: "INVOKE_FUNCTION" /* INVOKE */,
+            type: TransactionType.INVOKE,
             ...invocation,
             ...invocationDetails
           }
@@ -26009,7 +25988,7 @@ var starknet = (() => {
       return this.channel.getEstimateFee(
         [
           {
-            type: "DECLARE" /* DECLARE */,
+            type: TransactionType.DECLARE,
             ...invocation,
             ...details
           }
@@ -26021,7 +26000,7 @@ var starknet = (() => {
       return this.channel.getEstimateFee(
         [
           {
-            type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
+            type: TransactionType.DEPLOY_ACCOUNT,
             ...invocation,
             ...details
           }
@@ -26144,6 +26123,54 @@ var starknet = (() => {
       }
       throw Error(`Signature verification Error: ${error2}`);
     }
+    /**
+     * 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 (error2) {
+        if (error2 instanceof LibraryError) {
+          return false;
+        }
+        throw error2;
+      }
+    }
+    /**
+     * 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;
+    }
   };
 
   // node_modules/ts-mixer/dist/esm/index.js
@@ -26468,32 +26495,30 @@ var starknet = (() => {
     }
     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");
     }
@@ -26509,49 +26534,46 @@ var starknet = (() => {
         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"
@@ -27239,81 +27261,6 @@ var starknet = (() => {
     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, {
@@ -27453,6 +27400,81 @@ var starknet = (() => {
     };
   }
 
+  // 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, {
@@ -27620,6 +27642,7 @@ var starknet = (() => {
       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),
@@ -27642,6 +27665,7 @@ var starknet = (() => {
       });
     }
     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),
@@ -27674,7 +27698,7 @@ var starknet = (() => {
       );
       const estimate = await this.getUniversalSuggestedFee(
         version,
-        { type: "INVOKE_FUNCTION" /* INVOKE */, payload: transactions },
+        { type: TransactionType.INVOKE, payload: transactions },
         {
           ...details,
           version
@@ -27732,7 +27756,7 @@ var starknet = (() => {
       const estimate = await this.getUniversalSuggestedFee(
         version,
         {
-          type: "DECLARE" /* DECLARE */,
+          type: TransactionType.DECLARE,
           payload: declareContractPayload
         },
         {
@@ -27800,7 +27824,7 @@ var starknet = (() => {
       const estimate = await this.getUniversalSuggestedFee(
         version,
         {
-          type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
+          type: TransactionType.DEPLOY_ACCOUNT,
           payload: {
             classHash,
             constructorCalldata: compiledCalldata,
@@ -28042,16 +28066,16 @@ var starknet = (() => {
     async getSuggestedFee({ type, payload }, details) {
       let feeEstimate;
       switch (type) {
-        case "INVOKE_FUNCTION" /* INVOKE */:
+        case TransactionType.INVOKE:
           feeEstimate = await this.estimateInvokeFee(payload, details);
           break;
-        case "DECLARE" /* DECLARE */:
+        case TransactionType.DECLARE:
           feeEstimate = await this.estimateDeclareFee(payload, details);
           break;
-        case "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */:
+        case TransactionType.DEPLOY_ACCOUNT:
           feeEstimate = await this.estimateAccountDeployFee(payload, details);
           break;
-        case "DEPLOY" /* DEPLOY */:
+        case TransactionType.DEPLOY:
           feeEstimate = await this.estimateDeployFee(payload, details);
           break;
         default:
@@ -28153,7 +28177,7 @@ var starknet = (() => {
       const chainId = await this.getChainId();
       const versions = details.versions.map((it) => toTransactionVersion(it));
       const tx0Payload = "payload" in invocations[0] ? invocations[0].payload : invocations[0];
-      const cairoVersion = invocations[0].type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */ ? await this.getCairoVersion(tx0Payload.classHash) : await this.getCairoVersion();
+      const cairoVersion = invocations[0].type === TransactionType.DEPLOY_ACCOUNT ? await this.getCairoVersion(tx0Payload.classHash) : await this.getCairoVersion();
       return Promise.all(
         [].concat(invocations).map(async (transaction, index) => {
           const txPayload = "payload" in transaction ? transaction.payload : transaction;
@@ -28173,7 +28197,7 @@ var starknet = (() => {
             blockIdentifier,
             version: ""
           };
-          if (transaction.type === "INVOKE_FUNCTION" /* INVOKE */) {
+          if (transaction.type === TransactionType.INVOKE) {
             const versionX = reduceV2(versions[1]);
             signerDetails.version = versionX;
             common2.version = versionX;
@@ -28186,7 +28210,7 @@ var starknet = (() => {
               ...payload
             };
           }
-          if (transaction.type === "DEPLOY" /* DEPLOY */) {
+          if (transaction.type === TransactionType.DEPLOY) {
             const versionX = reduceV2(versions[1]);
             signerDetails.version = versionX;
             common2.version = versionX;
@@ -28195,10 +28219,10 @@ var starknet = (() => {
             return {
               ...common2,
               ...payload,
-              type: "INVOKE_FUNCTION" /* INVOKE */
+              type: TransactionType.INVOKE
             };
           }
-          if (transaction.type === "DECLARE" /* DECLARE */) {
+          if (transaction.type === TransactionType.DECLARE) {
             const versionX = !isSierra(txPayload.contract) ? versions[0] : versions[1];
             signerDetails.version = versionX;
             common2.version = versionX;
@@ -28208,7 +28232,7 @@ var starknet = (() => {
               ...payload
             };
           }
-          if (transaction.type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */) {
+          if (transaction.type === TransactionType.DEPLOY_ACCOUNT) {
             const versionX = reduceV2(versions[1]);
             signerDetails.version = versionX;
             common2.version = versionX;
@@ -28561,7 +28585,7 @@ var starknet = (() => {
       assert(this.address !== null, "contract is not connected to an address");
       const calldata = getCalldata(args, () => {
         if (parseRequest) {
-          this.callData.validate("CALL" /* CALL */, method, args);
+          this.callData.validate(ValidateType.CALL, method, args);
           return this.callData.compile(method, args);
         }
         console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
@@ -28588,7 +28612,7 @@ var starknet = (() => {
       assert(this.address !== null, "contract is not connected to an address");
       const calldata = getCalldata(args, () => {
         if (parseRequest) {
-          this.callData.validate("INVOKE" /* INVOKE */, method, args);
+          this.callData.validate(ValidateType.INVOKE, method, args);
           return this.callData.compile(method, args);
         }
         console.warn("Invoke skipped parsing but provided rawArgs, possible malfunction request");
@@ -28620,7 +28644,7 @@ var starknet = (() => {
     async estimate(method, args = []) {
       assert(this.address !== null, "contract is not connected to an address");
       if (!getCalldata(args, () => false)) {
-        this.callData.validate("INVOKE" /* INVOKE */, method, args);
+        this.callData.validate(ValidateType.INVOKE, method, args);
       }
       const invocation = this.populate(method, args);
       if ("estimateInvokeFee" in this.providerOrAccount) {
@@ -28702,7 +28726,7 @@ var starknet = (() => {
       const { args: param, options = { parseRequest: true } } = splitArgsAndOptions(args);
       const constructorCalldata = getCalldata(param, () => {
         if (options.parseRequest) {
-          this.CallData.validate("DEPLOY" /* DEPLOY */, "constructor", param);
+          this.CallData.validate(ValidateType.DEPLOY, "constructor", param);
           return this.CallData.compile("constructor", param);
         }
         console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");