starknet 5.1.1 → 5.3.0

package/dist/index.js

@@ -28,9 +28,11 @@ var src_exports = {};
 __export(src_exports, {
   Account: () => Account,
   AccountInterface: () => AccountInterface,
+  CallData: () => CallData,
   Contract: () => Contract,
   ContractFactory: () => ContractFactory,
   ContractInterface: () => ContractInterface,
+  EntryPointType: () => EntryPointType,
   GatewayError: () => GatewayError,
   HttpError: () => HttpError,
   LibraryError: () => LibraryError,
@@ -66,7 +68,15 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/types/lib.ts
+// src/types/lib/contract/index.ts
+var EntryPointType = /* @__PURE__ */ ((EntryPointType2) => {
+  EntryPointType2["EXTERNAL"] = "EXTERNAL";
+  EntryPointType2["L1_HANDLER"] = "L1_HANDLER";
+  EntryPointType2["CONSTRUCTOR"] = "CONSTRUCTOR";
+  return EntryPointType2;
+})(EntryPointType || {});
+
+// src/types/lib/index.ts
 var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
   TransactionStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
   TransactionStatus2["RECEIVED"] = "RECEIVED";
@@ -110,19 +120,23 @@ __export(hash_exports, {
   calculateDeployTransactionHash: () => calculateDeployTransactionHash,
   calculateTransactionHash: () => calculateTransactionHash,
   calculateTransactionHashCommon: () => calculateTransactionHashCommon,
+  computeCompiledClassHash: () => computeCompiledClassHash,
   computeContractClassHash: () => computeContractClassHash,
   computeHashOnElements: () => computeHashOnElements,
+  computeLegacyContractClassHash: () => computeLegacyContractClassHash,
+  computeSierraContractClassHash: () => computeSierraContractClassHash,
   default: () => computeHintedClassHash,
   feeTransactionVersion: () => feeTransactionVersion,
+  formatSpaces: () => formatSpaces,
   getSelector: () => getSelector,
   getSelectorFromName: () => getSelectorFromName,
   keccakBn: () => keccakBn,
   poseidon: () => poseidon,
   starknetKeccak: () => starknetKeccak,
-  transactionVersion: () => transactionVersion
+  transactionVersion: () => transactionVersion,
+  transactionVersion_2: () => transactionVersion_2
 });
-var import_keccak = require("ethereum-cryptography/keccak.js");
-var import_utils = require("ethereum-cryptography/utils.js");
+var import_micro_starknet = require("micro-starknet");
 
 // src/constants.ts
 var constants_exports = {};
@@ -2289,6 +2303,7 @@ __export(num_exports, {
   getDecimalString: () => getDecimalString,
   getHexString: () => getHexString,
   getHexStringArray: () => getHexStringArray,
+  hexToBytes: () => hexToBytes,
   hexToDecimalString: () => hexToDecimalString,
   isBigInt: () => isBigInt,
   isHex: () => isHex,
@@ -2298,6 +2313,7 @@ __export(num_exports, {
   toHex: () => toHex,
   toHexString: () => toHexString
 });
+var import_utils = require("@noble/curves/abstract/utils");
 
 // src/utils/assert.ts
 function assert(condition, message) {
@@ -2363,6 +2379,15 @@ function getHexStringArray(value) {
   return value.map((el) => getHexString(el));
 }
 var toCairoBool = (value) => (+value).toString();
+function hexToBytes(value) {
+  if (!isHex(value))
+    throw new Error(`${value} need to be a hex-string`);
+  let adaptedValue = removeHexPrefix(value);
+  if (adaptedValue.length % 2 !== 0) {
+    adaptedValue = `0${adaptedValue}`;
+  }
+  return (0, import_utils.hexToBytes)(adaptedValue);
+}
 
 // src/utils/shortString.ts
 var shortString_exports = {};
@@ -2477,7 +2502,7 @@ __export(ec_exports, {
   starkCurve: () => starkCurve,
   weierstrass: () => weierstrass
 });
-var starkCurve = __toESM(require("@noble/curves/stark"));
+var starkCurve = __toESM(require("micro-starknet"));
 var weierstrass = __toESM(require("@noble/curves/abstract/weierstrass"));
 
 // src/utils/json.ts
@@ -2505,14 +2530,15 @@ var json_default = { parse, stringify };
 // src/utils/hash.ts
 var poseidon = __toESM(require("@noble/curves/abstract/poseidon"));
 var transactionVersion = 1n;
+var transactionVersion_2 = 2n;
 var feeTransactionVersion = 2n ** 128n + transactionVersion;
 function keccakBn(value) {
   const hexWithoutPrefix = removeHexPrefix(toHex(BigInt(value)));
   const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
-  return addHexPrefix(buf2hex((0, import_keccak.keccak256)((0, import_utils.hexToBytes)(evenHex))));
+  return addHexPrefix((0, import_micro_starknet.keccak)(hexToBytes(addHexPrefix(evenHex))).toString(16));
 }
 function keccakHex(value) {
-  return addHexPrefix(buf2hex((0, import_keccak.keccak256)(utf8ToArray(value))));
+  return addHexPrefix((0, import_micro_starknet.keccak)(utf8ToArray(value)).toString(16));
 }
 function starknetKeccak(value) {
   const hash = BigInt(keccakHex(value));
@@ -2558,7 +2584,7 @@ function calculateDeployTransactionHash(contractAddress, constructorCalldata, ve
     chainId
   );
 }
-function calculateDeclareTransactionHash(classHash, senderAddress, version, maxFee, chainId, nonce) {
+function calculateDeclareTransactionHash(classHash, senderAddress, version, maxFee, chainId, nonce, compiledClassHash) {
   return calculateTransactionHashCommon(
     "0x6465636c617265" /* DECLARE */,
     version,
@@ -2567,7 +2593,7 @@ function calculateDeclareTransactionHash(classHash, senderAddress, version, maxF
     [classHash],
     maxFee,
     chainId,
-    [nonce]
+    [nonce, ...compiledClassHash ? [compiledClassHash] : []]
   );
 }
 function calculateDeployAccountTransactionHash(contractAddress, classHash, constructorCalldata, salt, version, maxFee, chainId, nonce) {
@@ -2615,32 +2641,28 @@ function nullSkipReplacer(key, value) {
   }
   return value === null ? void 0 : value;
 }
+function formatSpaces(json2) {
+  let insideQuotes = false;
+  let newString = "";
+  for (const char of json2) {
+    if (char === '"' && newString.endsWith("\\") === false) {
+      insideQuotes = !insideQuotes;
+    }
+    if (insideQuotes) {
+      newString += char;
+    } else {
+      newString += char === ":" ? ": " : char === "," ? ", " : char;
+    }
+  }
+  return newString;
+}
 function computeHintedClassHash(compiledContract) {
   const { abi, program } = compiledContract;
   const contractClass = { abi, program };
-  const serialisedJson = stringify(contractClass, nullSkipReplacer).split("").reduce(
-    ([insideQuotes, newString], char) => {
-      if (char === '"' && newString[newString.length - 1] !== "\\") {
-        insideQuotes = !insideQuotes;
-      }
-      if (insideQuotes) {
-        newString += char;
-        return [insideQuotes, newString];
-      }
-      if (char === ":" && !insideQuotes) {
-        newString += ": ";
-      } else if (char === "," && !insideQuotes) {
-        newString += ", ";
-      } else {
-        newString += char;
-      }
-      return [insideQuotes, newString];
-    },
-    [false, ""]
-  )[1];
-  return addHexPrefix(starkCurve.keccak(utf8ToArray(serialisedJson)).toString(16));
+  const serializedJson = formatSpaces(stringify(contractClass, nullSkipReplacer));
+  return addHexPrefix(starkCurve.keccak(utf8ToArray(serializedJson)).toString(16));
 }
-function computeContractClassHash(contract) {
+function computeLegacyContractClassHash(contract) {
   const compiledContract = typeof contract === "string" ? parse(contract) : contract;
   const apiVersion = toHex(API_VERSION);
   const externalEntryPointsHash = computeHashOnElements(
@@ -2667,6 +2689,95 @@ function computeContractClassHash(contract) {
     dataHash
   ]);
 }
+function hashBuiltins(builtins) {
+  return (0, import_micro_starknet.poseidonHashMany)(
+    builtins.flatMap((it) => {
+      return BigInt(encodeShortString(it));
+    })
+  );
+}
+function hashEntryPoint(data) {
+  const base = data.flatMap((it) => {
+    return [BigInt(it.selector), BigInt(it.offset), hashBuiltins(it.builtins)];
+  });
+  return (0, import_micro_starknet.poseidonHashMany)(base);
+}
+function computeCompiledClassHash(casm) {
+  const COMPILED_CLASS_VERSION = "COMPILED_CLASS_V1";
+  const compiledClassVersion = BigInt(encodeShortString(COMPILED_CLASS_VERSION));
+  const externalEntryPointsHash = hashEntryPoint(casm.entry_points_by_type.EXTERNAL);
+  const l1Handlers = hashEntryPoint(casm.entry_points_by_type.L1_HANDLER);
+  const constructor = hashEntryPoint(casm.entry_points_by_type.CONSTRUCTOR);
+  const bytecode = (0, import_micro_starknet.poseidonHashMany)(casm.bytecode.map((it) => BigInt(it)));
+  return toHex(
+    (0, import_micro_starknet.poseidonHashMany)([
+      compiledClassVersion,
+      externalEntryPointsHash,
+      l1Handlers,
+      constructor,
+      bytecode
+    ])
+  );
+}
+function hashEntryPointSierra(data) {
+  const base = data.flatMap((it) => {
+    return [BigInt(it.selector), BigInt(it.function_idx)];
+  });
+  return (0, import_micro_starknet.poseidonHashMany)(base);
+}
+function hashAbi(sierra) {
+  const indentString = formatSpaces(stringify(sierra.abi, null));
+  return BigInt(addHexPrefix(starkCurve.keccak(utf8ToArray(indentString)).toString(16)));
+}
+function computeSierraContractClassHash(sierra) {
+  const CONTRACT_CLASS_VERSION = "CONTRACT_CLASS_V0.1.0";
+  const compiledClassVersion = BigInt(encodeShortString(CONTRACT_CLASS_VERSION));
+  const externalEntryPointsHash = hashEntryPointSierra(sierra.entry_points_by_type.EXTERNAL);
+  const l1Handlers = hashEntryPointSierra(sierra.entry_points_by_type.L1_HANDLER);
+  const constructor = hashEntryPointSierra(sierra.entry_points_by_type.CONSTRUCTOR);
+  const abiHash = hashAbi(sierra);
+  const sierraProgram = (0, import_micro_starknet.poseidonHashMany)(sierra.sierra_program.map((it) => BigInt(it)));
+  return toHex(
+    (0, import_micro_starknet.poseidonHashMany)([
+      compiledClassVersion,
+      externalEntryPointsHash,
+      l1Handlers,
+      constructor,
+      abiHash,
+      sierraProgram
+    ])
+  );
+}
+function computeContractClassHash(contract) {
+  const compiledContract = typeof contract === "string" ? parse(contract) : contract;
+  if ("sierra_program" in compiledContract) {
+    return computeSierraContractClassHash(compiledContract);
+  }
+  return computeLegacyContractClassHash(compiledContract);
+}
+
+// src/utils/contract.ts
+var import_json_bigint2 = require("json-bigint");
+function isSierra(contract) {
+  const compiledContract = typeof contract === "string" ? (0, import_json_bigint2.parse)(contract) : contract;
+  return "sierra_program" in compiledContract;
+}
+function extractContractHashes(payload) {
+  const response = { ...payload };
+  if (isSierra(payload.contract)) {
+    if (!payload.compiledClassHash && payload.casm) {
+      response.compiledClassHash = computeCompiledClassHash(payload.casm);
+    }
+    if (!response.compiledClassHash)
+      throw new Error(
+        "Extract compiledClassHash failed, provide (CairoAssembly).casm file or compiledClassHash"
+      );
+  }
+  response.classHash = payload.classHash ?? computeContractClassHash(payload.contract);
+  if (!response.classHash)
+    throw new Error("Extract classHash failed, provide (CompiledContract).json file or classHash");
+  return response;
+}
 
 // src/utils/stark.ts
 var stark_exports = {};
@@ -2681,7 +2792,7 @@ __export(stark_exports, {
   signatureToDecimalArray: () => signatureToDecimalArray,
   signatureToHexArray: () => signatureToHexArray
 });
-var import_stark = require("@noble/curves/stark");
+var import_micro_starknet2 = require("micro-starknet");
 var import_pako = require("pako");
 function compressProgram(jsonProgram) {
   const stringified = typeof jsonProgram === "string" ? jsonProgram : stringify(jsonProgram);
@@ -2689,8 +2800,8 @@ function compressProgram(jsonProgram) {
   return btoaUniversal(compressedProgram);
 }
 function randomAddress() {
-  const randomKeyPair = import_stark.utils.randomPrivateKey();
-  return (0, import_stark.getStarkKey)(randomKeyPair);
+  const randomKeyPair = import_micro_starknet2.utils.randomPrivateKey();
+  return (0, import_micro_starknet2.getStarkKey)(randomKeyPair);
 }
 function makeAddress(input) {
   return addHexPrefix(input).toLowerCase();
@@ -2715,7 +2826,7 @@ function parseSignature(sig) {
   if (!sig)
     return void 0;
   const [r, s] = sig;
-  return new import_stark.Signature(toBigInt(r), toBigInt(s));
+  return new import_micro_starknet2.Signature(toBigInt(r), toBigInt(s));
 }
 function compileCalldata(args) {
   const compiledData = Object.values(args).flatMap((value) => {
@@ -2751,12 +2862,23 @@ function parseCalldata(calldata = []) {
     return toHex(data);
   });
 }
+function createSierraContractClass(contract) {
+  const result = { ...contract };
+  delete result.sierra_program_debug_info;
+  result.abi = formatSpaces(stringify(contract.abi));
+  result.sierra_program = formatSpaces(stringify(contract.sierra_program));
+  result.sierra_program = compressProgram(result.sierra_program);
+  return result;
+}
 function parseContract(contract) {
   const parsedContract = typeof contract === "string" ? parse(contract) : contract;
-  return {
-    ...parsedContract,
-    program: compressProgram(parsedContract.program)
-  };
+  if (!isSierra(contract)) {
+    return {
+      ...parsedContract,
+      ..."program" in parsedContract && { program: compressProgram(parsedContract.program) }
+    };
+  }
+  return createSierraContractClass(parsedContract);
 }
 
 // src/utils/responseParser/rpc.ts
@@ -2776,6 +2898,7 @@ var RPCResponseParser = class {
     return {
       calldata: res.calldata || [],
       contract_address: res.contract_address,
+      sender_address: res.contract_address,
       max_fee: res.max_fee,
       nonce: res.nonce,
       signature: res.signature || [],
@@ -3145,22 +3268,25 @@ var RpcProvider = class {
   }
   async getDeclareEstimateFee({ senderAddress, contractDefinition, signature }, details, blockIdentifier = this.blockIdentifier) {
     const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_estimateFee", {
-      request: {
-        type: RPC.TransactionType.DECLARE,
-        contract_class: {
-          program: contractDefinition.program,
-          entry_points_by_type: contractDefinition.entry_points_by_type,
-          abi: contractDefinition.abi
+    if ("program" in contractDefinition) {
+      return this.fetchEndpoint("starknet_estimateFee", {
+        request: {
+          type: RPC.TransactionType.DECLARE,
+          contract_class: {
+            program: contractDefinition.program,
+            entry_points_by_type: contractDefinition.entry_points_by_type,
+            abi: contractDefinition.abi
+          },
+          sender_address: senderAddress,
+          signature: signatureToHexArray(signature),
+          version: toHex((details == null ? void 0 : details.version) || 0),
+          nonce: toHex(details.nonce),
+          max_fee: toHex((details == null ? void 0 : details.maxFee) || 0)
         },
-        sender_address: senderAddress,
-        signature: signatureToHexArray(signature),
-        version: toHex((details == null ? void 0 : details.version) || 0),
-        nonce: toHex(details.nonce),
-        max_fee: toHex((details == null ? void 0 : details.maxFee) || 0)
-      },
-      block_id
-    }).then(this.responseParser.parseFeeEstimateResponse);
+        block_id
+      }).then(this.responseParser.parseFeeEstimateResponse);
+    }
+    throw new Error("RPC do not support Sierra Contracts yet");
   }
   async getDeployAccountEstimateFee({ classHash, constructorCalldata, addressSalt, signature }, details, blockIdentifier = this.blockIdentifier) {
     const block_id = new Block(blockIdentifier).identifier;
@@ -3182,21 +3308,24 @@ var RpcProvider = class {
     throw new Error("RPC does not implement getInvokeEstimateFeeBulk function");
   }
   async declareContract({ contractDefinition, signature, senderAddress }, details) {
-    return this.fetchEndpoint("starknet_addDeclareTransaction", {
-      declare_transaction: {
-        contract_class: {
-          program: contractDefinition.program,
-          entry_points_by_type: contractDefinition.entry_points_by_type,
-          abi: contractDefinition.abi
-        },
-        type: RPC.TransactionType.DECLARE,
-        version: toHex(details.version || 0),
-        max_fee: toHex(details.maxFee || 0),
-        signature: signatureToHexArray(signature),
-        sender_address: senderAddress,
-        nonce: toHex(details.nonce)
-      }
-    });
+    if ("program" in contractDefinition) {
+      return this.fetchEndpoint("starknet_addDeclareTransaction", {
+        declare_transaction: {
+          contract_class: {
+            program: contractDefinition.program,
+            entry_points_by_type: contractDefinition.entry_points_by_type,
+            abi: contractDefinition.abi
+          },
+          type: RPC.TransactionType.DECLARE,
+          version: "0x1",
+          max_fee: toHex(details.maxFee || 0),
+          signature: signatureToHexArray(signature),
+          sender_address: senderAddress,
+          nonce: toHex(details.nonce)
+        }
+      });
+    }
+    throw new Error("RPC do not support Sierra Contracts yet");
   }
   async deployAccountContract({ classHash, constructorCalldata, addressSalt, signature }, details) {
     return this.fetchEndpoint("starknet_addDeployAccountTransaction", {
@@ -3219,7 +3348,7 @@ var RpcProvider = class {
         calldata: parseCalldata(functionInvocation.calldata),
         type: RPC.TransactionType.INVOKE,
         max_fee: toHex(details.maxFee || 0),
-        version: toHex(details.version || 1),
+        version: "0x1",
         signature: signatureToHexArray(functionInvocation.signature),
         nonce: toHex(details.nonce)
       }
@@ -3328,7 +3457,6 @@ var SequencerAPIResponseParser = class extends ResponseParser {
     return {
       ...res,
       calldata: "calldata" in res.transaction ? res.transaction.calldata : [],
-      contract_address: "contract_address" in res.transaction ? res.transaction.contract_address : void 0,
       contract_class: "contract_class" in res.transaction ? res.transaction.contract_class : void 0,
       entry_point_selector: "entry_point_selector" in res.transaction ? res.transaction.entry_point_selector : void 0,
       max_fee: "max_fee" in res.transaction ? res.transaction.max_fee : void 0,
@@ -3446,24 +3574,18 @@ var SequencerAPIResponseParser = class extends ResponseParser {
     };
   }
   parseGetStateUpdateResponse(res) {
-    const nonces = [].concat(res.state_diff.nonces).map(({ contract_address, nonce }) => {
-      return {
-        contract_address,
-        nonce
-      };
-    });
-    const storage_diffs = [].concat(res.state_diff.storage_diffs).map(({ address, storage_entries }) => {
-      return {
-        address,
-        storage_entries
-      };
-    });
+    const nonces = Object.entries(res.state_diff.nonces).map(([contract_address, nonce]) => ({
+      contract_address,
+      nonce
+    }));
+    const storage_diffs = Object.entries(res.state_diff.storage_diffs).map(
+      ([address, storage_entries]) => ({ address, storage_entries })
+    );
     return {
       ...res,
       state_diff: {
+        ...res.state_diff,
         storage_diffs,
-        declared_contract_hashes: res.state_diff.declared_contract_hashes,
-        deployed_contracts: res.state_diff.deployed_contracts,
         nonces
       }
     };
@@ -3637,7 +3759,6 @@ var SequencerProvider = class {
       "call_contract",
       { blockIdentifier },
       {
-        signature: [],
         contract_address: contractAddress,
         entry_point_selector: getSelectorFromName(entryPointSelector),
         calldata
@@ -3682,18 +3803,23 @@ var SequencerProvider = class {
   async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
     return this.fetchEndpoint("get_class_hash_at", { blockIdentifier, contractAddress });
   }
-  async getClassByHash(classHash) {
-    return this.fetchEndpoint("get_class_by_hash", { classHash }).then(parseContract);
+  async getClassByHash(classHash, blockIdentifier = this.blockIdentifier) {
+    return this.fetchEndpoint("get_class_by_hash", { classHash, blockIdentifier }).then(
+      parseContract
+    );
+  }
+  async getCompiledClassByClassHash(classHash, blockIdentifier = this.blockIdentifier) {
+    return this.fetchEndpoint("get_compiled_class_by_class_hash", { classHash, blockIdentifier });
   }
   async invokeFunction(functionInvocation, details) {
     return this.fetchEndpoint("add_transaction", void 0, {
       type: "INVOKE_FUNCTION" /* INVOKE */,
-      contract_address: functionInvocation.contractAddress,
+      sender_address: functionInvocation.contractAddress,
       calldata: bigNumberishArrayToDecimalStringArray(functionInvocation.calldata ?? []),
       signature: signatureToDecimalArray(functionInvocation.signature),
       nonce: toHex(details.nonce),
       max_fee: toHex(details.maxFee || 0),
-      version: toHex(details.version || 1)
+      version: "0x1"
     }).then(this.responseParser.parseInvokeFunctionResponse);
   }
   async deployAccountContract({ classHash, constructorCalldata, addressSalt, signature }, details) {
@@ -3708,27 +3834,39 @@ var SequencerProvider = class {
       signature: signatureToDecimalArray(signature)
     }).then(this.responseParser.parseDeployContractResponse);
   }
-  async declareContract({ senderAddress, contractDefinition, signature }, details) {
+  async declareContract({ senderAddress, contractDefinition, signature, compiledClassHash }, details) {
+    if (!isSierra(contractDefinition)) {
+      return this.fetchEndpoint("add_transaction", void 0, {
+        type: "DECLARE" /* DECLARE */,
+        contract_class: contractDefinition,
+        nonce: toHex(details.nonce),
+        signature: signatureToDecimalArray(signature),
+        sender_address: senderAddress,
+        max_fee: toHex(details.maxFee || 0),
+        version: "0x1"
+      }).then(this.responseParser.parseDeclareContractResponse);
+    }
     return this.fetchEndpoint("add_transaction", void 0, {
       type: "DECLARE" /* DECLARE */,
+      sender_address: senderAddress,
+      compiled_class_hash: compiledClassHash,
       contract_class: contractDefinition,
       nonce: toHex(details.nonce),
       signature: signatureToDecimalArray(signature),
-      sender_address: senderAddress,
       max_fee: toHex(details.maxFee || 0),
-      version: toHex(details.version || 1)
+      version: "0x2"
     }).then(this.responseParser.parseDeclareContractResponse);
   }
-  async getEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier) {
-    return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier);
+  async getEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier, skipValidate = false) {
+    return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier, skipValidate);
   }
-  async getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier) {
+  async getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier, skipValidate = false) {
     return this.fetchEndpoint(
       "estimate_fee",
-      { blockIdentifier },
+      { blockIdentifier, skipValidate },
       {
         type: "INVOKE_FUNCTION" /* INVOKE */,
-        contract_address: invocation.contractAddress,
+        sender_address: invocation.contractAddress,
         calldata: invocation.calldata ?? [],
         signature: signatureToDecimalArray(invocation.signature),
         version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
@@ -3736,24 +3874,39 @@ var SequencerProvider = class {
       }
     ).then(this.responseParser.parseFeeEstimateResponse);
   }
-  async getDeclareEstimateFee({ senderAddress, contractDefinition, signature }, details, blockIdentifier = this.blockIdentifier) {
+  async getDeclareEstimateFee({ senderAddress, contractDefinition, signature, compiledClassHash }, details, blockIdentifier = this.blockIdentifier, skipValidate = false) {
+    if (!isSierra(contractDefinition)) {
+      return this.fetchEndpoint(
+        "estimate_fee",
+        { blockIdentifier, skipValidate },
+        {
+          type: "DECLARE" /* DECLARE */,
+          sender_address: senderAddress,
+          contract_class: contractDefinition,
+          signature: signatureToDecimalArray(signature),
+          version: toHex((details == null ? void 0 : details.version) || toBigInt(feeTransactionVersion)),
+          nonce: toHex(details.nonce)
+        }
+      ).then(this.responseParser.parseFeeEstimateResponse);
+    }
     return this.fetchEndpoint(
       "estimate_fee",
-      { blockIdentifier },
+      { blockIdentifier, skipValidate },
       {
         type: "DECLARE" /* DECLARE */,
         sender_address: senderAddress,
+        compiled_class_hash: compiledClassHash,
         contract_class: contractDefinition,
+        nonce: toHex(details.nonce),
         signature: signatureToDecimalArray(signature),
-        version: toHex((details == null ? void 0 : details.version) || 1),
-        nonce: toHex(details.nonce)
+        version: "0x2"
       }
     ).then(this.responseParser.parseFeeEstimateResponse);
   }
-  async getDeployAccountEstimateFee({ classHash, addressSalt, constructorCalldata, signature }, details, blockIdentifier = this.blockIdentifier) {
+  async getDeployAccountEstimateFee({ classHash, addressSalt, constructorCalldata, signature }, details, blockIdentifier = this.blockIdentifier, skipValidate = false) {
     return this.fetchEndpoint(
       "estimate_fee",
-      { blockIdentifier },
+      { blockIdentifier, skipValidate },
       {
         type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
         class_hash: toHex(classHash),
@@ -3771,7 +3924,7 @@ var SequencerProvider = class {
       if (invocation.type === "INVOKE_FUNCTION") {
         res = {
           type: invocation.type,
-          contract_address: invocation.contractAddress,
+          sender_address: invocation.contractAddress,
           calldata: invocation.calldata ?? []
         };
       } else if (invocation.type === "DECLARE") {
@@ -3850,13 +4003,13 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     };
     return this.fetchEndpoint("estimate_message_fee", { blockIdentifier }, validCallL1Handler);
   }
-  async getSimulateTransaction(invocation, invocationDetails, blockIdentifier = this.blockIdentifier) {
+  async getSimulateTransaction(invocation, invocationDetails, blockIdentifier = this.blockIdentifier, skipValidate = false) {
     return this.fetchEndpoint(
       "simulate_transaction",
-      { blockIdentifier },
+      { blockIdentifier, skipValidate },
       {
         type: "INVOKE_FUNCTION",
-        contract_address: invocation.contractAddress,
+        sender_address: invocation.contractAddress,
         calldata: invocation.calldata ?? [],
         signature: signatureToDecimalArray(invocation.signature),
         version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
@@ -3916,11 +4069,12 @@ var Provider = class {
   async getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier) {
     return this.provider.getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier);
   }
-  async getInvokeEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier) {
+  async getInvokeEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier, skipValidate) {
     return this.provider.getInvokeEstimateFee(
       invocationWithTxType,
       invocationDetails,
-      blockIdentifier
+      blockIdentifier,
+      skipValidate
     );
   }
   async getEstimateFeeBulk(invocations, blockIdentifier) {
@@ -3950,11 +4104,16 @@ var Provider = class {
   async declareContract(transaction, details) {
     return this.provider.declareContract(transaction, details);
   }
-  async getDeclareEstimateFee(transaction, details, blockIdentifier) {
-    return this.provider.getDeclareEstimateFee(transaction, details, blockIdentifier);
+  async getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate) {
+    return this.provider.getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate);
   }
-  getDeployAccountEstimateFee(transaction, details, blockIdentifier) {
-    return this.provider.getDeployAccountEstimateFee(transaction, details, blockIdentifier);
+  getDeployAccountEstimateFee(transaction, details, blockIdentifier, skipValidate) {
+    return this.provider.getDeployAccountEstimateFee(
+      transaction,
+      details,
+      blockIdentifier,
+      skipValidate
+    );
   }
   async getCode(contractAddress, blockIdentifier) {
     return this.provider.getCode(contractAddress, blockIdentifier);
@@ -3962,8 +4121,13 @@ var Provider = class {
   async waitForTransaction(txHash, options) {
     return this.provider.waitForTransaction(txHash, options);
   }
-  async getSimulateTransaction(invocation, invocationDetails, blockIdentifier) {
-    return this.provider.getSimulateTransaction(invocation, invocationDetails, blockIdentifier);
+  async getSimulateTransaction(invocation, invocationDetails, blockIdentifier, skipValidate) {
+    return this.provider.getSimulateTransaction(
+      invocation,
+      invocationDetails,
+      blockIdentifier,
+      skipValidate
+    );
   }
   async getStateUpdate(blockIdentifier) {
     return this.provider.getStateUpdate(blockIdentifier);
@@ -4941,14 +5105,23 @@ var Signer = class {
     );
     return starkCurve.sign(msgHash, this.pk);
   }
-  async signDeclareTransaction({ classHash, senderAddress, chainId, maxFee, version, nonce }) {
+  async signDeclareTransaction({
+    classHash,
+    senderAddress,
+    chainId,
+    maxFee,
+    version,
+    nonce,
+    compiledClassHash
+  }) {
     const msgHash = calculateDeclareTransactionHash(
       classHash,
       senderAddress,
       version,
       maxFee,
       chainId,
-      nonce
+      nonce,
+      compiledClassHash
     );
     return starkCurve.sign(msgHash, this.pk);
   }
@@ -4990,7 +5163,7 @@ var Account = class extends Provider {
   async estimateFee(calls, estimateFeeDetails) {
     return this.estimateInvokeFee(calls, estimateFeeDetails);
   }
-  async estimateInvokeFee(calls, { nonce: providedNonce, blockIdentifier } = {}) {
+  async estimateInvokeFee(calls, { nonce: providedNonce, blockIdentifier, skipValidate } = {}) {
     const transactions = Array.isArray(calls) ? calls : [calls];
     const nonce = toBigInt(providedNonce ?? await this.getNonce());
     const version = toBigInt(feeTransactionVersion);
@@ -5006,7 +5179,8 @@ var Account = class extends Provider {
     const response = await super.getInvokeEstimateFee(
       { ...invocation },
       { version, nonce },
-      blockIdentifier
+      blockIdentifier,
+      skipValidate
     );
     const suggestedMaxFee = estimatedFeeToMaxFee(response.overall_fee);
     return {
@@ -5014,18 +5188,19 @@ var Account = class extends Provider {
       suggestedMaxFee
     };
   }
-  async estimateDeclareFee({ contract, classHash: providedClassHash }, { blockIdentifier, nonce: providedNonce } = {}) {
+  async estimateDeclareFee({ contract, classHash: providedClassHash, casm, compiledClassHash }, { blockIdentifier, nonce: providedNonce, skipValidate } = {}) {
     const nonce = toBigInt(providedNonce ?? await this.getNonce());
-    const version = toBigInt(feeTransactionVersion);
+    const version = !isSierra(contract) ? toBigInt(feeTransactionVersion) : transactionVersion_2;
     const chainId = await this.getChainId();
-    const payload = await this.buildDeclarePayload(
-      { classHash: providedClassHash, contract },
+    const declareContractTransaction = await this.buildDeclarePayload(
+      { classHash: providedClassHash, contract, casm, compiledClassHash },
       { nonce, chainId, version, walletAddress: this.address, maxFee: ZERO }
     );
     const response = await super.getDeclareEstimateFee(
-      { ...payload },
+      declareContractTransaction,
       { version, nonce },
-      blockIdentifier
+      blockIdentifier,
+      skipValidate
     );
     const suggestedMaxFee = estimatedFeeToMaxFee(response.overall_fee);
     return {
@@ -5038,7 +5213,7 @@ var Account = class extends Provider {
     addressSalt = 0,
     constructorCalldata = [],
     contractAddress: providedContractAddress
-  }, { blockIdentifier } = {}) {
+  }, { blockIdentifier, skipValidate } = {}) {
     const version = toBigInt(feeTransactionVersion);
     const nonce = ZERO;
     const chainId = await this.getChainId();
@@ -5049,7 +5224,8 @@ var Account = class extends Provider {
     const response = await super.getDeployAccountEstimateFee(
       { ...payload },
       { version, nonce },
-      blockIdentifier
+      blockIdentifier,
+      skipValidate
     );
     const suggestedMaxFee = estimatedFeeToMaxFee(response.overall_fee);
     return {
@@ -5165,32 +5341,24 @@ var Account = class extends Provider {
       }
     );
   }
-  async declare({ contract, classHash: providedClassHash }, transactionsDetail = {}) {
-    const nonce = toBigInt(transactionsDetail.nonce ?? await this.getNonce());
-    const classHash = providedClassHash ?? computeContractClassHash(contract);
-    const maxFee = transactionsDetail.maxFee ?? await this.getSuggestedMaxFee(
-      { type: "DECLARE" /* DECLARE */, payload: { classHash, contract } },
+  async declare(payload, transactionsDetail = {}) {
+    const declareContractPayload = extractContractHashes(payload);
+    const details = {};
+    details.nonce = toBigInt(transactionsDetail.nonce ?? await this.getNonce());
+    details.maxFee = transactionsDetail.maxFee ?? await this.getSuggestedMaxFee(
+      {
+        type: "DECLARE" /* DECLARE */,
+        payload: declareContractPayload
+      },
       transactionsDetail
     );
-    const version = toBigInt(transactionVersion);
-    const chainId = await this.getChainId();
-    const signature = await this.signer.signDeclareTransaction({
-      classHash,
-      senderAddress: this.address,
-      chainId,
-      maxFee,
-      version,
-      nonce
+    details.version = !isSierra(payload.contract) ? transactionVersion : transactionVersion_2;
+    details.chainId = await this.getChainId();
+    const declareContractTransaction = await this.buildDeclarePayload(declareContractPayload, {
+      ...details,
+      walletAddress: this.address
     });
-    const contractDefinition = parseContract(contract);
-    return this.declareContract(
-      { contractDefinition, senderAddress: this.address, signature },
-      {
-        nonce,
-        maxFee,
-        version
-      }
-    );
+    return this.declareContract(declareContractTransaction, details);
   }
   async deploy(payload, details) {
     const params = [].concat(payload).map((it) => {
@@ -5331,11 +5499,12 @@ var Account = class extends Provider {
     }
     return feeEstimate.suggestedMaxFee.toString();
   }
-  async buildDeclarePayload({ classHash: providedClassHash, contract }, { nonce, chainId, version, walletAddress, maxFee }) {
+  async buildDeclarePayload(payload, { nonce, chainId, version, walletAddress, maxFee }) {
+    const { classHash, contract, compiledClassHash } = extractContractHashes(payload);
     const contractDefinition = parseContract(contract);
-    const classHash = providedClassHash ?? computeContractClassHash(contract);
     const signature = await this.signer.signDeclareTransaction({
       classHash,
+      compiledClassHash,
       senderAddress: walletAddress,
       chainId,
       maxFee,
@@ -5345,7 +5514,8 @@ var Account = class extends Provider {
     return {
       senderAddress: walletAddress,
       signature,
-      contractDefinition
+      contractDefinition,
+      compiledClassHash
     };
   }
   async buildAccountDeployPayload({
@@ -5395,7 +5565,7 @@ var Account = class extends Provider {
     });
     return calls;
   }
-  async simulateTransaction(calls, { nonce: providedNonce, blockIdentifier } = {}) {
+  async simulateTransaction(calls, { nonce: providedNonce, blockIdentifier, skipValidate } = {}) {
     const transactions = Array.isArray(calls) ? calls : [calls];
     const nonce = toBigInt(providedNonce ?? await this.getNonce());
     const version = toBigInt(feeTransactionVersion);
@@ -5411,7 +5581,8 @@ var Account = class extends Provider {
     const response = await super.getSimulateTransaction(
       invocation,
       { version, nonce },
-      blockIdentifier
+      blockIdentifier,
+      skipValidate
     );
     const suggestedMaxFee = estimatedFeeToMaxFee(response.fee_estimation.overall_fee);
     return {
@@ -5432,7 +5603,7 @@ var AccountInterface = class extends ProviderInterface {
 };
 
 // src/utils/address.ts
-var import_bytes = require("@ethersproject/bytes");
+var import_utils5 = require("@noble/curves/abstract/utils");
 function addAddressPadding(address) {
   return addHexPrefix(removeHexPrefix(toHex(address)).padStart(64, "0"));
 }
@@ -5446,7 +5617,8 @@ function validateAndParseAddress(address) {
 }
 function getChecksumAddress(address) {
   const chars = removeHexPrefix(validateAndParseAddress(address)).toLowerCase().split("");
-  const hashed = (0, import_bytes.arrayify)(keccakBn(address), { hexPad: "left" });
+  const hex = removeHexPrefix(keccakBn(address));
+  const hashed = (0, import_utils5.hexToBytes)(hex.padStart(64, "0"));
   for (let i = 0; i < chars.length; i += 2) {
     if (hashed[i >> 1] >> 4 >= 8) {
       chars[i] = chars[i].toUpperCase();
@@ -5467,9 +5639,11 @@ var number = num_exports;
 0 && (module.exports = {
   Account,
   AccountInterface,
+  CallData,
   Contract,
   ContractFactory,
   ContractInterface,
+  EntryPointType,
   GatewayError,
   HttpError,
   LibraryError,