starknet 5.26.1 → 5.28.0

package/dist/index.global.js

@@ -665,7 +665,7 @@ var starknet = (() => {
     GatewayError: () => GatewayError,
     HttpError: () => HttpError,
     LibraryError: () => LibraryError,
-    Litteral: () => Litteral,
+    Literal: () => Literal,
     Provider: () => Provider,
     ProviderInterface: () => ProviderInterface,
     RPC: () => rpc_exports,
@@ -679,6 +679,7 @@ var starknet = (() => {
     TransactionFinalityStatus: () => TransactionFinalityStatus,
     TransactionStatus: () => TransactionStatus,
     TransactionType: () => TransactionType,
+    TypedDataRevision: () => TypedDataRevision,
     Uint: () => Uint,
     ValidateType: () => ValidateType,
     addAddressPadding: () => addAddressPadding,
@@ -1057,7 +1058,7 @@ var starknet = (() => {
     BlockStatus: () => BlockStatus,
     BlockTag: () => BlockTag,
     EntryPointType: () => EntryPointType,
-    Litteral: () => Litteral,
+    Literal: () => Literal,
     RPC: () => rpc_exports,
     SIMULATION_FLAG: () => SIMULATION_FLAG,
     Sequencer: () => sequencer_exports,
@@ -1065,6 +1066,7 @@ var starknet = (() => {
     TransactionFinalityStatus: () => TransactionFinalityStatus,
     TransactionStatus: () => TransactionStatus,
     TransactionType: () => TransactionType,
+    TypedDataRevision: () => TypedDataRevision,
     Uint: () => Uint,
     ValidateType: () => ValidateType
   });
@@ -1092,11 +1094,11 @@ var starknet = (() => {
     Uint2["u256"] = "core::integer::u256";
     return Uint2;
   })(Uint || {});
-  var Litteral = /* @__PURE__ */ ((Litteral2) => {
-    Litteral2["ClassHash"] = "core::starknet::class_hash::ClassHash";
-    Litteral2["ContractAddress"] = "core::starknet::contract_address::ContractAddress";
-    return Litteral2;
-  })(Litteral || {});
+  var Literal = /* @__PURE__ */ ((Literal2) => {
+    Literal2["ClassHash"] = "core::starknet::class_hash::ClassHash";
+    Literal2["ContractAddress"] = "core::starknet::contract_address::ContractAddress";
+    return Literal2;
+  })(Literal || {});
 
   // src/types/lib/contract/index.ts
   var EntryPointType = /* @__PURE__ */ ((EntryPointType2) => {
@@ -1149,6 +1151,13 @@ var starknet = (() => {
     return BlockTag2;
   })(BlockTag || {});
 
+  // src/types/typedData.ts
+  var TypedDataRevision = /* @__PURE__ */ ((TypedDataRevision2) => {
+    TypedDataRevision2["Active"] = "1";
+    TypedDataRevision2["Legacy"] = "0";
+    return TypedDataRevision2;
+  })(TypedDataRevision || {});
+
   // src/types/api/rpc.ts
   var rpc_exports = {};
   __export(rpc_exports, {
@@ -3963,7 +3972,7 @@ var starknet = (() => {
     isTypeEnum: () => isTypeEnum,
     isTypeEthAddress: () => isTypeEthAddress,
     isTypeFelt: () => isTypeFelt,
-    isTypeLitteral: () => isTypeLitteral,
+    isTypeLiteral: () => isTypeLiteral,
     isTypeNamedTuple: () => isTypeNamedTuple,
     isTypeOption: () => isTypeOption,
     isTypeResult: () => isTypeResult,
@@ -4013,7 +4022,7 @@ var starknet = (() => {
   var isTypeOption = (type) => type.startsWith("core::option::Option::");
   var isTypeResult = (type) => type.startsWith("core::result::Result::");
   var isTypeUint = (type) => Object.values(Uint).includes(type);
-  var isTypeLitteral = (type) => Object.values(Litteral).includes(type);
+  var isTypeLiteral = (type) => Object.values(Literal).includes(type);
   var isTypeUint256 = (type) => type === "core::integer::u256";
   var isTypeBool = (type) => type === "core::bool";
   var isTypeContractAddress = (type) => type === "core::starknet::contract_address::ContractAddress";
@@ -4086,13 +4095,21 @@ var starknet = (() => {
 
   // src/utils/calldata/enum/CairoCustomEnum.ts
   var CairoCustomEnum = class {
+    /**
+     * direct readonly access to variants of the Cairo Custom Enum.
+     * @returns a value of type any
+     * @example
+     * ```typescript
+     * const successValue = myCairoEnum.variant.Success;
+     */
+    variant;
     /**
      * @param enumContent an object with the variants as keys and the content as value. Only one content shall be defined.
      */
     constructor(enumContent) {
       const variantsList = Object.values(enumContent);
       if (variantsList.length === 0) {
-        throw new Error("This Enum must have a least 1 variant");
+        throw new Error("This Enum must have at least 1 variant");
       }
       const nbActiveVariants = variantsList.filter(
         (content) => typeof content !== "undefined"
@@ -4135,6 +4152,8 @@ var starknet = (() => {
     return CairoOptionVariant2;
   })(CairoOptionVariant || {});
   var CairoOption = class {
+    Some;
+    None;
     constructor(variant, someContent) {
       if (!(variant in CairoOptionVariant)) {
         throw new Error("Wrong variant : should be CairoOptionVariant.Some or .None.");
@@ -4186,6 +4205,8 @@ var starknet = (() => {
     return CairoResultVariant2;
   })(CairoResultVariant || {});
   var CairoResult = class {
+    Ok;
+    Err;
     constructor(variant, resultContent) {
       if (!(variant in CairoResultVariant)) {
         throw new Error("Wrong variant : should be CairoResultVariant.Ok or .Err.");
@@ -4284,6 +4305,7 @@ var starknet = (() => {
 
   // src/utils/calldata/parser/parser-0-1.1.0.ts
   var AbiParser1 = class {
+    abi;
     constructor(abi) {
       this.abi = abi;
     }
@@ -4315,6 +4337,7 @@ var starknet = (() => {
 
   // src/utils/calldata/parser/parser-2.0.0.ts
   var AbiParser2 = class {
+    abi;
     constructor(abi) {
       this.abi = abi;
     }
@@ -5060,7 +5083,7 @@ var starknet = (() => {
       case isTypeEnum(baseType, enums):
         parameter.forEach((it) => validateEnum(it, { name: input.name, type: baseType }));
         break;
-      case (isTypeUint(baseType) || isTypeLitteral(baseType)):
+      case (isTypeUint(baseType) || isTypeLiteral(baseType)):
         parameter.forEach((param) => validateUint(param, input));
         break;
       case isTypeBool(baseType):
@@ -5081,7 +5104,7 @@ var starknet = (() => {
         case isTypeFelt(input.type):
           validateFelt(parameter, input);
           break;
-        case (isTypeUint(input.type) || isTypeLitteral(input.type)):
+        case (isTypeUint(input.type) || isTypeLiteral(input.type)):
           validateUint(parameter, input);
           break;
         case isTypeBool(input.type):
@@ -5110,6 +5133,10 @@ var starknet = (() => {
 
   // src/utils/calldata/index.ts
   var CallData = class {
+    abi;
+    parser;
+    structs;
+    enums;
     constructor(abi) {
       this.structs = CallData.getAbiStruct(abi);
       this.enums = CallData.getAbiEnum(abi);
@@ -5354,6 +5381,10 @@ var starknet = (() => {
     computeContractClassHash: () => computeContractClassHash,
     computeHashOnElements: () => computeHashOnElements2,
     computeLegacyContractClassHash: () => computeLegacyContractClassHash,
+    computePedersenHash: () => computePedersenHash,
+    computePedersenHashOnElements: () => computePedersenHashOnElements,
+    computePoseidonHash: () => computePoseidonHash,
+    computePoseidonHashOnElements: () => computePoseidonHashOnElements,
     computeSierraContractClassHash: () => computeSierraContractClassHash,
     default: () => computeHintedClassHash,
     feeTransactionVersion: () => feeTransactionVersion,
@@ -6063,8 +6094,18 @@ var starknet = (() => {
   function getVersionsByType(versionType) {
     return versionType === "fee" ? { v1: feeTransactionVersion, v2: feeTransactionVersion_2 } : { v1: transactionVersion, v2: transactionVersion_2 };
   }
+  function computePedersenHash(a, b) {
+    return esm_exports.pedersen(BigInt(a), BigInt(b));
+  }
+  function computePoseidonHash(a, b) {
+    return toHex(esm_exports.poseidonHash(BigInt(a), BigInt(b)));
+  }
   function computeHashOnElements2(data) {
-    return [...data, data.length].reduce((x, y) => esm_exports.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
+    return [...data, data.length].reduce((x, y) => esm_exports.pedersen(BigInt(x), BigInt(y)), 0).toString();
+  }
+  var computePedersenHashOnElements = computeHashOnElements2;
+  function computePoseidonHashOnElements(data) {
+    return toHex(poseidonHashMany(data.map((x) => BigInt(x))));
   }
   function calculateTransactionHashCommon(txHashPrefix, version, contractAddress, entryPointSelector, calldata, maxFee, chainId, additionalData = []) {
     const calldataHash = computeHashOnElements2(calldata);
@@ -10620,6 +10661,7 @@ var starknet = (() => {
     setPrototypeOf ? setPrototypeOf(target, prototype) : target.__proto__ = prototype;
   }
   var CustomError = class extends Error {
+    name;
     constructor(message) {
       super(message);
       Object.defineProperty(this, "name", {
@@ -10796,14 +10838,9 @@ var starknet = (() => {
   // src/provider/utils.ts
   var validBlockTags = Object.values(BlockTag);
   var Block = class {
-    constructor(_identifier) {
-      this.hash = null;
-      this.number = null;
-      this.tag = null;
-      this.valueOf = () => this.number;
-      this.toString = () => this.hash;
-      this.setIdentifier(_identifier);
-    }
+    hash = null;
+    number = null;
+    tag = null;
     setIdentifier(__identifier) {
       if (typeof __identifier === "string" && isHex(__identifier)) {
         this.hash = __identifier;
@@ -10817,6 +10854,9 @@ var starknet = (() => {
         this.tag = "pending" /* pending */;
       }
     }
+    constructor(_identifier) {
+      this.setIdentifier(_identifier);
+    }
     // TODO: fix any
     get queryIdentifier() {
       if (this.number !== null) {
@@ -10840,6 +10880,8 @@ var starknet = (() => {
     set identifier(_identifier) {
       this.setIdentifier(_identifier);
     }
+    valueOf = () => this.number;
+    toString = () => this.hash;
     get sequencerIdentifier() {
       return this.hash !== null ? { blockHash: this.hash } : { blockNumber: this.number ?? this.tag };
     }
@@ -10859,36 +10901,13 @@ var starknet = (() => {
     retries: 200
   };
   var RpcProvider = class {
+    nodeUrl;
+    headers;
+    responseParser = new RPCResponseParser();
+    retries;
+    blockIdentifier;
+    chainId;
     constructor(optionsOrProvider) {
-      this.responseParser = new RPCResponseParser();
-      /**
-       * @deprecated renamed to getBlockLatestAccepted(); (will be removed in next minor version)
-       */
-      this.getBlockHashAndNumber = this.getBlockLatestAccepted;
-      /**
-       * @deprecated renamed to getBlockStateUpdate();
-       */
-      this.getStateUpdate = this.getBlockStateUpdate;
-      /**
-       * Returns the execution traces of all transactions included in the given block
-       * @deprecated renamed to getBlockTransactionsTraces()
-       */
-      this.traceBlockTransactions = this.getBlockTransactionsTraces;
-      /**
-       * Get the number of transactions in a block given a block id
-       * @deprecated renamed to getBlockTransactionCount()
-       * @returns Number of transactions
-       */
-      this.getTransactionCount = this.getBlockTransactionCount;
-      /**
-       * @deprecated renamed to getTransactionTrace();
-       * For a given executed transaction, return the trace of its execution, including internal calls
-       */
-      this.traceTransaction = this.getTransactionTrace;
-      /**
-       * @deprecated renamed to simulateTransaction();
-       */
-      this.getSimulateTransaction = this.simulateTransaction;
       const { nodeUrl, retries, headers, blockIdentifier, chainId, rpcVersion } = optionsOrProvider || {};
       if (Object.values(NetworkName).includes(nodeUrl)) {
         this.nodeUrl = getDefaultNodeUrl(
@@ -10946,7 +10965,7 @@ var starknet = (() => {
       }
     }
     async getChainId() {
-      this.chainId ?? (this.chainId = await this.fetchEndpoint("starknet_chainId"));
+      this.chainId ??= await this.fetchEndpoint("starknet_chainId");
       return this.chainId;
     }
     /**
@@ -10971,6 +10990,10 @@ var starknet = (() => {
         this.responseParser.parseGetBlockResponse
       );
     }
+    /**
+     * @deprecated renamed to getBlockLatestAccepted(); (will be removed in next minor version)
+     */
+    getBlockHashAndNumber = this.getBlockLatestAccepted;
     /**
      * Get the most recent accepted block hash and number
      */
@@ -10997,14 +11020,29 @@ var starknet = (() => {
       const block_id = new Block(blockIdentifier).identifier;
       return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
     }
+    /**
+     * @deprecated renamed to getBlockStateUpdate();
+     */
+    getStateUpdate = this.getBlockStateUpdate;
     async getBlockTransactionsTraces(blockIdentifier = this.blockIdentifier) {
       const block_id = new Block(blockIdentifier).identifier;
       return this.fetchEndpoint("starknet_traceBlockTransactions", { block_id });
     }
+    /**
+     * Returns the execution traces of all transactions included in the given block
+     * @deprecated renamed to getBlockTransactionsTraces()
+     */
+    traceBlockTransactions = this.getBlockTransactionsTraces;
     async getBlockTransactionCount(blockIdentifier = this.blockIdentifier) {
       const block_id = new Block(blockIdentifier).identifier;
       return this.fetchEndpoint("starknet_getBlockTransactionCount", { block_id });
     }
+    /**
+     * Get the number of transactions in a block given a block id
+     * @deprecated renamed to getBlockTransactionCount()
+     * @returns Number of transactions
+     */
+    getTransactionCount = this.getBlockTransactionCount;
     /**
      * Return transactions from pending block
      * @deprecated Instead use getBlock(BlockTag.pending); (will be removed in next minor version)
@@ -11037,6 +11075,11 @@ var starknet = (() => {
       const transaction_hash = toHex(txHash);
       return this.fetchEndpoint("starknet_traceTransaction", { transaction_hash });
     }
+    /**
+     * @deprecated renamed to getTransactionTrace();
+     * For a given executed transaction, return the trace of its execution, including internal calls
+     */
+    traceTransaction = this.getTransactionTrace;
     /**
      * NEW: Get the status of a transaction
      */
@@ -11044,6 +11087,10 @@ var starknet = (() => {
       const transaction_hash = toHex(transactionHash);
       return this.fetchEndpoint("starknet_getTransactionStatus", { transaction_hash });
     }
+    /**
+     * @deprecated renamed to simulateTransaction();
+     */
+    getSimulateTransaction = this.simulateTransaction;
     /**
      * @param invocations AccountInvocations
      * @param simulateTransactionOptions blockIdentifier and flags to skip validation and fee charge<br/>
@@ -11598,8 +11645,14 @@ var starknet = (() => {
     blockIdentifier: "pending" /* pending */
   };
   var SequencerProvider = class {
+    baseUrl;
+    feederGatewayUrl;
+    gatewayUrl;
+    headers;
+    blockIdentifier;
+    chainId;
+    responseParser = new SequencerAPIResponseParser();
     constructor(optionsOrProvider = defaultOptions2) {
-      this.responseParser = new SequencerAPIResponseParser();
       if ("network" in optionsOrProvider) {
         this.baseUrl = SequencerProvider.getNetworkFromName(optionsOrProvider.network);
         this.feederGatewayUrl = buildUrl(this.baseUrl, "feeder_gateway");
@@ -11788,7 +11841,7 @@ var starknet = (() => {
       } else if (classHash) {
         contractClass = await this.getClassByHash(classHash, blockIdentifier);
       } else {
-        throw Error("getContractVersion require contractAddress or classHash");
+        throw Error("getContractVersion requires contractAddress or classHash");
       }
       if (isSierra(contractClass)) {
         if (compiler) {
@@ -12077,6 +12130,7 @@ ${res.tx_failure_reason.error_message}`;
 
   // src/provider/default.ts
   var Provider = class {
+    provider;
     constructor(providerOrOptions) {
       if (providerOrOptions instanceof Provider) {
         this.provider = providerOrOptions.provider;
@@ -12244,6 +12298,8 @@ ${res.tx_failure_reason.error_message}`;
   // src/utils/typedData.ts
   var typedData_exports = {};
   __export(typedData_exports, {
+    TypedDataRevision: () => TypedDataRevision,
+    byteArrayFromString: () => byteArrayFromString,
     encodeData: () => encodeData,
     encodeType: () => encodeType,
     encodeValue: () => encodeValue,
@@ -12262,8 +12318,12 @@ ${res.tx_failure_reason.error_message}`;
     proofMerklePath: () => proofMerklePath
   });
   var MerkleTree = class {
-    constructor(leafHashes) {
-      this.branches = [];
+    leaves;
+    branches = [];
+    root;
+    hashMethod;
+    constructor(leafHashes, hashMethod = computePedersenHash) {
+      this.hashMethod = hashMethod;
       this.leaves = leafHashes;
       this.root = this.build(leafHashes);
     }
@@ -12282,20 +12342,20 @@ ${res.tx_failure_reason.error_message}`;
       const newLeaves = [];
       for (let i = 0; i < leaves.length; i += 2) {
         if (i + 1 === leaves.length) {
-          newLeaves.push(MerkleTree.hash(leaves[i], "0x0"));
+          newLeaves.push(MerkleTree.hash(leaves[i], "0x0", this.hashMethod));
         } else {
-          newLeaves.push(MerkleTree.hash(leaves[i], leaves[i + 1]));
+          newLeaves.push(MerkleTree.hash(leaves[i], leaves[i + 1], this.hashMethod));
         }
       }
       return this.build(newLeaves);
     }
     /**
-     * Create pedersen hash from a and b
+     * Create hash from ordered a and b, Pedersen hash default
      * @returns format: hex-string
      */
-    static hash(a, b) {
-      const [aSorted, bSorted] = [toBigInt(a), toBigInt(b)].sort((x, y) => x >= y ? 1 : -1);
-      return esm_exports.pedersen(aSorted, bSorted);
+    static hash(a, b, hashMethod = computePedersenHash) {
+      const [aSorted, bSorted] = [BigInt(a), BigInt(b)].sort((x, y) => x >= y ? 1 : -1);
+      return hashMethod(aSorted, bSorted);
     }
     /**
      * Return path to leaf
@@ -12318,21 +12378,64 @@ ${res.tx_failure_reason.error_message}`;
       const currentBranchLevelIndex = this.leaves.length === branch.length ? -1 : this.branches.findIndex((b) => b.length === branch.length);
       const nextBranch = this.branches[currentBranchLevelIndex + 1] ?? [this.root];
       return this.getProof(
-        MerkleTree.hash(isLeft ? leaf : neededBranch, isLeft ? neededBranch : leaf),
+        MerkleTree.hash(isLeft ? leaf : neededBranch, isLeft ? neededBranch : leaf, this.hashMethod),
         nextBranch,
         newHashPath
       );
     }
   };
-  function proofMerklePath(root, leaf, path) {
+  function proofMerklePath(root, leaf, path, hashMethod = computePedersenHash) {
     if (path.length === 0) {
       return root === leaf;
     }
     const [next, ...rest] = path;
-    return proofMerklePath(root, MerkleTree.hash(leaf, next), rest);
+    return proofMerklePath(root, MerkleTree.hash(leaf, next, hashMethod), rest, hashMethod);
   }
 
   // src/utils/typedData.ts
+  var presetTypes = {
+    u256: JSON.parse('[{ "name": "low", "type": "u128" }, { "name": "high", "type": "u128" }]'),
+    TokenAmount: JSON.parse(
+      '[{ "name": "token_address", "type": "ContractAddress" }, { "name": "amount", "type": "u256" }]'
+    ),
+    NftId: JSON.parse(
+      '[{ "name": "collection_address", "type": "ContractAddress" }, { "name": "token_id", "type": "u256" }]'
+    )
+  };
+  var revisionConfiguration = {
+    ["1" /* Active */]: {
+      domain: "StarknetDomain",
+      hashMethod: computePoseidonHashOnElements,
+      hashMerkleMethod: computePoseidonHash,
+      escapeTypeString: (s) => `"${s}"`,
+      presetTypes
+    },
+    ["0" /* Legacy */]: {
+      domain: "StarkNetDomain",
+      hashMethod: computePedersenHashOnElements,
+      hashMerkleMethod: computePedersenHash,
+      escapeTypeString: (s) => s,
+      presetTypes: {}
+    }
+  };
+  function byteArrayFromString(targetString) {
+    const shortStrings = splitLongString(targetString);
+    const remainder = shortStrings[shortStrings.length - 1];
+    const shortStringsEncoded = shortStrings.map(encodeShortString);
+    const [pendingWord, pendingWordLength] = remainder === void 0 || remainder.length === 31 ? ["0x00", 0] : [shortStringsEncoded.pop(), remainder.length];
+    return {
+      data: shortStringsEncoded.length === 0 ? ["0x00"] : shortStringsEncoded,
+      pending_word: pendingWord,
+      pending_word_len: pendingWordLength
+    };
+  }
+  function identifyRevision({ types, domain }) {
+    if (revisionConfiguration["1" /* Active */].domain in types && domain.revision === "1" /* Active */)
+      return "1" /* Active */;
+    if (revisionConfiguration["0" /* Legacy */].domain in types && (domain.revision ?? "0" /* Legacy */) === "0" /* Legacy */)
+      return "0" /* Legacy */;
+    return void 0;
+  }
   function getHex(value) {
     try {
       return toHex(value);
@@ -12343,25 +12446,29 @@ ${res.tx_failure_reason.error_message}`;
       throw new Error(`Invalid BigNumberish: ${value}`);
     }
   }
-  var validateTypedData = (data) => {
+  function validateTypedData(data) {
     const typedData = data;
-    const valid = Boolean(typedData.types && typedData.primaryType && typedData.message);
-    return valid;
-  };
+    return Boolean(
+      typedData.message && typedData.primaryType && typedData.types && identifyRevision(typedData)
+    );
+  }
   function prepareSelector(selector) {
     return isHex(selector) ? selector : getSelectorFromName(selector);
   }
   function isMerkleTreeType(type) {
     return type.type === "merkletree";
   }
-  var getDependencies = (types, type, dependencies = []) => {
+  function getDependencies(types, type, dependencies = [], contains = "", revision = "0" /* Legacy */) {
     if (type[type.length - 1] === "*") {
       type = type.slice(0, -1);
+    } else if (revision === "1" /* Active */) {
+      if (type === "enum") {
+        type = contains;
+      } else if (type.match(/^\(.*\)$/)) {
+        type = type.slice(1, -1);
+      }
     }
-    if (dependencies.includes(type)) {
-      return dependencies;
-    }
-    if (!types[type]) {
+    if (dependencies.includes(type) || !types[type]) {
       return dependencies;
     }
     return [
@@ -12369,14 +12476,14 @@ ${res.tx_failure_reason.error_message}`;
       ...types[type].reduce(
         (previous, t) => [
           ...previous,
-          ...getDependencies(types, t.type, previous).filter(
+          ...getDependencies(types, t.type, previous, t.contains, revision).filter(
             (dependency) => !previous.includes(dependency)
           )
         ],
         []
       )
     ];
-  };
+  }
   function getMerkleTreeType(types, ctx) {
     if (ctx.parent && ctx.key) {
       const parentType = types[ctx.parent];
@@ -12392,80 +12499,148 @@ ${res.tx_failure_reason.error_message}`;
     }
     return "raw";
   }
-  var encodeType = (types, type) => {
-    const [primary, ...dependencies] = getDependencies(types, type);
+  function encodeType(types, type, revision = "0" /* Legacy */) {
+    const [primary, ...dependencies] = getDependencies(types, type, void 0, void 0, revision);
     const newTypes = !primary ? [] : [primary, ...dependencies.sort()];
+    const esc = revisionConfiguration[revision].escapeTypeString;
     return newTypes.map((dependency) => {
-      return `${dependency}(${types[dependency].map((t) => `${t.name}:${t.type}`)})`;
+      const dependencyElements = types[dependency].map((t) => {
+        const targetType = t.type === "enum" && revision === "1" /* Active */ ? t.contains : t.type;
+        const typeString = targetType.match(/^\(.*\)$/) ? `(${targetType.slice(1, -1).split(",").map((e) => e ? esc(e) : e).join(",")})` : esc(targetType);
+        return `${esc(t.name)}:${typeString}`;
+      });
+      return `${esc(dependency)}(${dependencyElements})`;
     }).join("");
-  };
-  var getTypeHash = (types, type) => {
-    return getSelectorFromName(encodeType(types, type));
-  };
-  var encodeValue = (types, type, data, ctx = {}) => {
+  }
+  function getTypeHash(types, type, revision = "0" /* Legacy */) {
+    return getSelectorFromName(encodeType(types, type, revision));
+  }
+  function encodeValue(types, type, data, ctx = {}, revision = "0" /* Legacy */) {
     if (types[type]) {
-      return [type, getStructHash(types, type, data)];
-    }
-    if (Object.keys(types).map((x) => `${x}*`).includes(type)) {
-      const structHashes = data.map((struct) => {
-        return getStructHash(types, type.slice(0, -1), struct);
-      });
-      return [type, computeHashOnElements2(structHashes)];
-    }
-    if (type === "merkletree") {
-      const merkleTreeType = getMerkleTreeType(types, ctx);
-      const structHashes = data.map((struct) => {
-        return encodeValue(types, merkleTreeType, struct)[1];
-      });
-      const { root } = new MerkleTree(structHashes);
-      return ["felt", root];
-    }
-    if (type === "felt*") {
-      return ["felt*", computeHashOnElements2(data)];
+      return [type, getStructHash(types, type, data, revision)];
     }
-    if (type === "selector") {
-      return ["felt", prepareSelector(data)];
+    if (revisionConfiguration[revision].presetTypes[type]) {
+      return [
+        type,
+        getStructHash(
+          revisionConfiguration[revision].presetTypes,
+          type,
+          data,
+          revision
+        )
+      ];
     }
-    return [type, getHex(data)];
-  };
-  var encodeData = (types, type, data) => {
-    const [returnTypes, values] = types[type].reduce(
+    if (type.endsWith("*")) {
+      const hashes = data.map(
+        (entry) => encodeValue(types, type.slice(0, -1), entry, void 0, revision)[1]
+      );
+      return [type, revisionConfiguration[revision].hashMethod(hashes)];
+    }
+    switch (type) {
+      case "enum": {
+        if (revision === "1" /* Active */) {
+          const [variantKey, variantData] = Object.entries(data)[0];
+          const parentType = types[ctx.parent][0];
+          const enumType = types[parentType.contains];
+          const variantType = enumType.find((t) => t.name === variantKey);
+          const variantIndex = enumType.indexOf(variantType);
+          const encodedSubtypes = variantType.type.slice(1, -1).split(",").map((subtype, index) => {
+            if (!subtype)
+              return subtype;
+            const subtypeData = variantData[index];
+            return encodeValue(types, subtype, subtypeData, void 0, revision)[1];
+          });
+          return [
+            type,
+            revisionConfiguration[revision].hashMethod([variantIndex, ...encodedSubtypes])
+          ];
+        }
+        return [type, getHex(data)];
+      }
+      case "merkletree": {
+        const merkleTreeType = getMerkleTreeType(types, ctx);
+        const structHashes = data.map((struct) => {
+          return encodeValue(types, merkleTreeType, struct, void 0, revision)[1];
+        });
+        const { root } = new MerkleTree(
+          structHashes,
+          revisionConfiguration[revision].hashMerkleMethod
+        );
+        return ["felt", root];
+      }
+      case "selector": {
+        return ["felt", prepareSelector(data)];
+      }
+      case "string": {
+        if (revision === "1" /* Active */) {
+          const byteArray = byteArrayFromString(data);
+          const elements = [
+            byteArray.data.length,
+            ...byteArray.data,
+            byteArray.pending_word,
+            byteArray.pending_word_len
+          ];
+          return [type, revisionConfiguration[revision].hashMethod(elements)];
+        }
+        return [type, getHex(data)];
+      }
+      case "felt":
+      case "bool":
+      case "u128":
+      case "i128":
+      case "ContractAddress":
+      case "ClassHash":
+      case "timestamp":
+      case "shortstring":
+        return [type, getHex(data)];
+      default: {
+        if (revision === "1" /* Active */) {
+          throw new Error(`Unsupported type: ${type}`);
+        }
+        return [type, getHex(data)];
+      }
+    }
+  }
+  function encodeData(types, type, data, revision = "0" /* Legacy */) {
+    const targetType = types[type] ?? revisionConfiguration[revision].presetTypes[type];
+    const [returnTypes, values] = targetType.reduce(
       ([ts, vs], field) => {
-        if (data[field.name] === void 0 || data[field.name] === null) {
+        if (data[field.name] === void 0 || data[field.name] === null && field.type !== "enum") {
           throw new Error(`Cannot encode data: missing data for '${field.name}'`);
         }
         const value = data[field.name];
-        const [t, encodedValue] = encodeValue(types, field.type, value, {
-          parent: type,
-          key: field.name
-        });
+        const ctx = { parent: type, key: field.name };
+        const [t, encodedValue] = encodeValue(types, field.type, value, ctx, revision);
         return [
           [...ts, t],
           [...vs, encodedValue]
         ];
       },
-      [["felt"], [getTypeHash(types, type)]]
+      [["felt"], [getTypeHash(types, type, revision)]]
     );
     return [returnTypes, values];
-  };
-  var getStructHash = (types, type, data) => {
-    return computeHashOnElements2(encodeData(types, type, data)[1]);
-  };
-  var getMessageHash = (typedData, account) => {
+  }
+  function getStructHash(types, type, data, revision = "0" /* Legacy */) {
+    return revisionConfiguration[revision].hashMethod(encodeData(types, type, data, revision)[1]);
+  }
+  function getMessageHash(typedData, account) {
     if (!validateTypedData(typedData)) {
       throw new Error("Typed data does not match JSON schema");
     }
+    const revision = identifyRevision(typedData);
+    const { domain, hashMethod } = revisionConfiguration[revision];
     const message = [
       encodeShortString("StarkNet Message"),
-      getStructHash(typedData.types, "StarkNetDomain", typedData.domain),
+      getStructHash(typedData.types, domain, typedData.domain, revision),
       account,
-      getStructHash(typedData.types, typedData.primaryType, typedData.message)
+      getStructHash(typedData.types, typedData.primaryType, typedData.message, revision)
     ];
-    return computeHashOnElements2(message);
-  };
+    return hashMethod(message);
+  }
 
   // src/signer/default.ts
   var Signer = class {
+    pk;
     constructor(pk = esm_exports.utils.randomPrivateKey()) {
       this.pk = pk instanceof Uint8Array ? buf2hex(pk) : toHex(pk);
     }
@@ -12560,9 +12735,11 @@ ${res.tx_failure_reason.error_message}`;
 
   // src/account/default.ts
   var Account = class extends Provider {
+    signer;
+    address;
+    cairoVersion;
     constructor(providerOrOptions, address, pkOrSigner, cairoVersion) {
       super(providerOrOptions);
-      this.deploySelf = this.deployAccount;
       this.address = address.toLowerCase();
       this.signer = typeof pkOrSigner === "string" || pkOrSigner instanceof Uint8Array ? new Signer(pkOrSigner) : pkOrSigner;
       if (cairoVersion) {
@@ -12835,6 +13012,7 @@ ${res.tx_failure_reason.error_message}`;
       );
       return { declare: { ...declare }, deploy };
     }
+    deploySelf = this.deployAccount;
     async deployAccount({
       classHash,
       constructorCalldata = [],
@@ -13198,6 +13376,17 @@ ${res.tx_failure_reason.error_message}`;
     return callback();
   }
   var Contract = class {
+    abi;
+    address;
+    providerOrAccount;
+    deployTransactionHash;
+    structs;
+    events;
+    functions;
+    callStatic;
+    populateTransaction;
+    estimateFee;
+    callData;
     /**
      * Contract class to handle contract methods
      *
@@ -13371,7 +13560,7 @@ ${res.tx_failure_reason.error_message}`;
     async getVersion() {
       return this.providerOrAccount.getContractVersion(this.address);
     }
-    typed(tAbi) {
+    typedv1(tAbi) {
       return this;
     }
     typedv2(tAbi) {
@@ -13381,10 +13570,21 @@ ${res.tx_failure_reason.error_message}`;
 
   // src/contract/interface.ts
   var ContractInterface = class {
+    functions;
+    callStatic;
+    populateTransaction;
+    estimateFee;
   };
 
   // src/contract/contractFactory.ts
   var ContractFactory = class {
+    compiledContract;
+    account;
+    abi;
+    classHash;
+    casm;
+    compiledClassHash;
+    CallData;
     /**
      * @param params CFParams
      *  - compiledContract: CompiledContract;
@@ -13452,7 +13652,7 @@ ${res.tx_failure_reason.error_message}`;
     attach(address) {
       return new Contract(this.abi, address, this.account);
     }
-    // ethers.js' getDeployTransaction cant be supported as it requires the account or signer to return a signed transaction which is not possible with the current implementation
+    // ethers.js' getDeployTransaction can't be supported as it requires the account or signer to return a signed transaction which is not possible with the current implementation
   };
 
   // src/utils/address.ts