starknet 5.26.1 → 5.28.0

package/dist/index.mjs

@@ -169,7 +169,7 @@ __export(types_exports, {
   BlockStatus: () => BlockStatus,
   BlockTag: () => BlockTag,
   EntryPointType: () => EntryPointType,
-  Litteral: () => Litteral,
+  Literal: () => Literal,
   RPC: () => rpc_exports,
   SIMULATION_FLAG: () => SIMULATION_FLAG,
   Sequencer: () => sequencer_exports,
@@ -177,6 +177,7 @@ __export(types_exports, {
   TransactionFinalityStatus: () => TransactionFinalityStatus,
   TransactionStatus: () => TransactionStatus,
   TransactionType: () => TransactionType,
+  TypedDataRevision: () => TypedDataRevision,
   Uint: () => Uint,
   ValidateType: () => ValidateType
 });
@@ -204,11 +205,11 @@ var Uint = /* @__PURE__ */ ((Uint2) => {
   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) => {
@@ -261,6 +262,13 @@ var BlockTag = /* @__PURE__ */ ((BlockTag2) => {
   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, {
@@ -528,7 +536,7 @@ __export(cairo_exports, {
   isTypeEnum: () => isTypeEnum,
   isTypeEthAddress: () => isTypeEthAddress,
   isTypeFelt: () => isTypeFelt,
-  isTypeLitteral: () => isTypeLitteral,
+  isTypeLiteral: () => isTypeLiteral,
   isTypeNamedTuple: () => isTypeNamedTuple,
   isTypeOption: () => isTypeOption,
   isTypeResult: () => isTypeResult,
@@ -578,7 +586,7 @@ var isTypeEnum = (type, enums) => type in enums;
 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";
@@ -651,13 +659,21 @@ function felt(it) {
 
 // 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"
@@ -700,6 +716,8 @@ var CairoOptionVariant = /* @__PURE__ */ ((CairoOptionVariant2) => {
   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.");
@@ -751,6 +769,8 @@ var CairoResultVariant = /* @__PURE__ */ ((CairoResultVariant2) => {
   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.");
@@ -849,6 +869,7 @@ function formatter(data, type, sameType) {
 
 // src/utils/calldata/parser/parser-0-1.1.0.ts
 var AbiParser1 = class {
+  abi;
   constructor(abi) {
     this.abi = abi;
   }
@@ -880,6 +901,7 @@ var AbiParser1 = class {
 
 // src/utils/calldata/parser/parser-2.0.0.ts
 var AbiParser2 = class {
+  abi;
   constructor(abi) {
     this.abi = abi;
   }
@@ -1625,7 +1647,7 @@ var validateArray = (parameter, input, structs, enums) => {
     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):
@@ -1646,7 +1668,7 @@ function validateFields(abiMethod, args, structs, enums) {
       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):
@@ -1675,6 +1697,10 @@ function validateFields(abiMethod, args, structs, enums) {
 
 // src/utils/calldata/index.ts
 var CallData = class {
+  abi;
+  parser;
+  structs;
+  enums;
   constructor(abi) {
     this.structs = CallData.getAbiStruct(abi);
     this.enums = CallData.getAbiEnum(abi);
@@ -1919,6 +1945,10 @@ __export(hash_exports, {
   computeContractClassHash: () => computeContractClassHash,
   computeHashOnElements: () => computeHashOnElements,
   computeLegacyContractClassHash: () => computeLegacyContractClassHash,
+  computePedersenHash: () => computePedersenHash,
+  computePedersenHashOnElements: () => computePedersenHashOnElements,
+  computePoseidonHash: () => computePoseidonHash,
+  computePoseidonHashOnElements: () => computePoseidonHashOnElements,
   computeSierraContractClassHash: () => computeSierraContractClassHash,
   default: () => computeHintedClassHash,
   feeTransactionVersion: () => feeTransactionVersion,
@@ -1973,8 +2003,18 @@ var feeTransactionVersion_2 = BN_FEE_TRANSACTION_VERSION_2;
 function getVersionsByType(versionType) {
   return versionType === "fee" ? { v1: feeTransactionVersion, v2: feeTransactionVersion_2 } : { v1: transactionVersion, v2: transactionVersion_2 };
 }
+function computePedersenHash(a, b) {
+  return starkCurve.pedersen(BigInt(a), BigInt(b));
+}
+function computePoseidonHash(a, b) {
+  return toHex(starkCurve.poseidonHash(BigInt(a), BigInt(b)));
+}
 function computeHashOnElements(data) {
-  return [...data, data.length].reduce((x, y) => starkCurve.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
+  return [...data, data.length].reduce((x, y) => starkCurve.pedersen(BigInt(x), BigInt(y)), 0).toString();
+}
+var computePedersenHashOnElements = computeHashOnElements;
+function computePoseidonHashOnElements(data) {
+  return toHex(poseidonHashMany(data.map((x) => BigInt(x))));
 }
 function calculateTransactionHashCommon(txHashPrefix, version, contractAddress, entryPointSelector, calldata, maxFee, chainId, additionalData = []) {
   const calldataHash = computeHashOnElements(calldata);
@@ -2367,6 +2407,7 @@ function fixProto(target, prototype) {
   setPrototypeOf ? setPrototypeOf(target, prototype) : target.__proto__ = prototype;
 }
 var CustomError = class extends Error {
+  name;
   constructor(message) {
     super(message);
     Object.defineProperty(this, "name", {
@@ -2543,14 +2584,9 @@ async function getAddressFromStarkName(provider, name, StarknetIdContract2) {
 // 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;
@@ -2564,6 +2600,9 @@ var Block = class {
       this.tag = "pending" /* pending */;
     }
   }
+  constructor(_identifier) {
+    this.setIdentifier(_identifier);
+  }
   // TODO: fix any
   get queryIdentifier() {
     if (this.number !== null) {
@@ -2587,6 +2626,8 @@ var Block = class {
   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 };
   }
@@ -2606,36 +2647,13 @@ var defaultOptions = {
   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(
@@ -2693,7 +2711,7 @@ var RpcProvider = class {
     }
   }
   async getChainId() {
-    this.chainId ?? (this.chainId = await this.fetchEndpoint("starknet_chainId"));
+    this.chainId ??= await this.fetchEndpoint("starknet_chainId");
     return this.chainId;
   }
   /**
@@ -2718,6 +2736,10 @@ var RpcProvider = class {
       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
    */
@@ -2744,14 +2766,29 @@ var RpcProvider = class {
     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)
@@ -2784,6 +2821,11 @@ var RpcProvider = class {
     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
    */
@@ -2791,6 +2833,10 @@ var RpcProvider = class {
     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/>
@@ -3345,8 +3391,14 @@ var defaultOptions2 = {
   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");
@@ -3535,7 +3587,7 @@ var SequencerProvider = class {
     } 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) {
@@ -3824,6 +3876,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;
@@ -3991,6 +4044,8 @@ var getExecuteCalldata = (calls, cairoVersion = "0") => {
 // src/utils/typedData.ts
 var typedData_exports = {};
 __export(typedData_exports, {
+  TypedDataRevision: () => TypedDataRevision,
+  byteArrayFromString: () => byteArrayFromString,
   encodeData: () => encodeData,
   encodeType: () => encodeType,
   encodeValue: () => encodeValue,
@@ -4009,8 +4064,12 @@ __export(merkle_exports, {
   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);
   }
@@ -4029,20 +4088,20 @@ var MerkleTree = class {
     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 starkCurve.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
@@ -4065,21 +4124,64 @@ var MerkleTree = class {
     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);
@@ -4090,25 +4192,29 @@ function getHex(value) {
     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 [
@@ -4116,14 +4222,14 @@ var getDependencies = (types, type, dependencies = []) => {
     ...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];
@@ -4139,80 +4245,148 @@ function getMerkleTreeType(types, ctx) {
   }
   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)];
+    return [type, getStructHash(types, type, data, revision)];
   }
-  if (Object.keys(types).map((x) => `${x}*`).includes(type)) {
-    const structHashes = data.map((struct) => {
-      return getStructHash(types, type.slice(0, -1), struct);
-    });
-    return [type, computeHashOnElements(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*", computeHashOnElements(data)];
+  if (revisionConfiguration[revision].presetTypes[type]) {
+    return [
+      type,
+      getStructHash(
+        revisionConfiguration[revision].presetTypes,
+        type,
+        data,
+        revision
+      )
+    ];
   }
-  if (type === "selector") {
-    return ["felt", prepareSelector(data)];
+  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)];
+    }
   }
-  return [type, getHex(data)];
-};
-var encodeData = (types, type, data) => {
-  const [returnTypes, values] = types[type].reduce(
+}
+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 computeHashOnElements(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 computeHashOnElements(message);
-};
+  return hashMethod(message);
+}
 
 // src/signer/default.ts
 var Signer = class {
+  pk;
   constructor(pk = starkCurve.utils.randomPrivateKey()) {
     this.pk = pk instanceof Uint8Array ? buf2hex(pk) : toHex(pk);
   }
@@ -4307,9 +4481,11 @@ function parseUDCEvent(txReceipt) {
 
 // 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) {
@@ -4582,6 +4758,7 @@ var Account = class extends Provider {
     );
     return { declare: { ...declare }, deploy };
   }
+  deploySelf = this.deployAccount;
   async deployAccount({
     classHash,
     constructorCalldata = [],
@@ -4945,6 +5122,17 @@ function getCalldata(args, callback) {
   return callback();
 }
 var Contract = class {
+  abi;
+  address;
+  providerOrAccount;
+  deployTransactionHash;
+  structs;
+  events;
+  functions;
+  callStatic;
+  populateTransaction;
+  estimateFee;
+  callData;
   /**
    * Contract class to handle contract methods
    *
@@ -5118,7 +5306,7 @@ var Contract = class {
   async getVersion() {
     return this.providerOrAccount.getContractVersion(this.address);
   }
-  typed(tAbi) {
+  typedv1(tAbi) {
     return this;
   }
   typedv2(tAbi) {
@@ -5128,10 +5316,21 @@ var Contract = class {
 
 // 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;
@@ -5199,7 +5398,7 @@ var ContractFactory = class {
   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
@@ -5254,7 +5453,7 @@ export {
   GatewayError,
   HttpError,
   LibraryError,
-  Litteral,
+  Literal,
   Provider,
   ProviderInterface,
   rpc_exports as RPC,
@@ -5268,6 +5467,7 @@ export {
   TransactionFinalityStatus,
   TransactionStatus,
   TransactionType,
+  TypedDataRevision,
   Uint,
   ValidateType,
   addAddressPadding,