starknet 5.2.0 → 5.4.0

package/dist/index.mjs

@@ -4,7 +4,15 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// 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";
@@ -52,20 +60,19 @@ __export(hash_exports, {
   computeContractClassHash: () => computeContractClassHash,
   computeHashOnElements: () => computeHashOnElements,
   computeLegacyContractClassHash: () => computeLegacyContractClassHash,
-  computeSieraContractClassHash: () => computeSieraContractClassHash,
+  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
 });
-import { keccak256 } from "ethereum-cryptography/keccak.js";
-import { hexToBytes } from "ethereum-cryptography/utils.js";
-import { sort } from "json-keys-sort";
-import { poseidonHashMany } from "micro-starknet";
+import { keccak, poseidonHashMany } from "micro-starknet";
 
 // src/constants.ts
 var constants_exports = {};
@@ -2232,6 +2239,7 @@ __export(num_exports, {
   getDecimalString: () => getDecimalString,
   getHexString: () => getHexString,
   getHexStringArray: () => getHexStringArray,
+  hexToBytes: () => hexToBytes,
   hexToDecimalString: () => hexToDecimalString,
   isBigInt: () => isBigInt,
   isHex: () => isHex,
@@ -2241,6 +2249,7 @@ __export(num_exports, {
   toHex: () => toHex,
   toHexString: () => toHexString
 });
+import { hexToBytes as hexToBytesNoble } from "@noble/curves/abstract/utils";
 
 // src/utils/assert.ts
 function assert(condition, message) {
@@ -2306,6 +2315,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 hexToBytesNoble(adaptedValue);
+}
 
 // src/utils/shortString.ts
 var shortString_exports = {};
@@ -2426,36 +2444,35 @@ import * as weierstrass from "@noble/curves/abstract/weierstrass";
 // src/utils/json.ts
 var json_exports = {};
 __export(json_exports, {
-  default: () => json_default,
-  parse: () => parse,
+  parse: () => parse2,
   parseAlwaysAsBig: () => parseAlwaysAsBig,
-  stringify: () => stringify,
+  stringify: () => stringify2,
   stringifyAlwaysAsBig: () => stringifyAlwaysAsBig
 });
-import Json from "json-bigint";
-var json = (alwaysParseAsBig) => {
-  return Json({
-    alwaysParseAsBig,
-    useNativeBigInt: true,
-    protoAction: "preserve",
-    constructorAction: "preserve"
-  });
+import * as json from "lossless-json";
+var parseIntAsNumberOrBigInt = (x) => {
+  if (!json.isInteger(x))
+    return parseFloat(x);
+  const v = parseInt(x, 10);
+  return Number.isSafeInteger(v) ? v : BigInt(x);
 };
-var { parse, stringify } = json(false);
-var { parse: parseAlwaysAsBig, stringify: stringifyAlwaysAsBig } = json(true);
-var json_default = { parse, stringify };
+var parse2 = (x) => json.parse(String(x), null, parseIntAsNumberOrBigInt);
+var parseAlwaysAsBig = (x) => json.parse(String(x), null, json.parseNumberAndBigInt);
+var stringify2 = (...p) => json.stringify(...p);
+var stringifyAlwaysAsBig = stringify2;
 
 // src/utils/hash.ts
 import * as poseidon from "@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(keccak256(hexToBytes(evenHex))));
+  return addHexPrefix(keccak(hexToBytes(addHexPrefix(evenHex))).toString(16));
 }
 function keccakHex(value) {
-  return addHexPrefix(buf2hex(keccak256(utf8ToArray(value))));
+  return addHexPrefix(keccak(utf8ToArray(value)).toString(16));
 }
 function starknetKeccak(value) {
   const hash = BigInt(keccakHex(value));
@@ -2501,7 +2518,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,
@@ -2510,7 +2527,7 @@ function calculateDeclareTransactionHash(classHash, senderAddress, version, maxF
     [classHash],
     maxFee,
     chainId,
-    [nonce]
+    [nonce, ...compiledClassHash ? [compiledClassHash] : []]
   );
 }
 function calculateDeployAccountTransactionHash(contractAddress, classHash, constructorCalldata, salt, version, maxFee, chainId, nonce) {
@@ -2576,11 +2593,11 @@ function formatSpaces(json2) {
 function computeHintedClassHash(compiledContract) {
   const { abi, program } = compiledContract;
   const contractClass = { abi, program };
-  const serializedJson = formatSpaces(stringify(contractClass, nullSkipReplacer));
+  const serializedJson = formatSpaces(stringify2(contractClass, nullSkipReplacer));
   return addHexPrefix(starkCurve.keccak(utf8ToArray(serializedJson)).toString(16));
 }
 function computeLegacyContractClassHash(contract) {
-  const compiledContract = typeof contract === "string" ? parse(contract) : contract;
+  const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
   const apiVersion = toHex(API_VERSION);
   const externalEntryPointsHash = computeHashOnElements(
     compiledContract.entry_points_by_type.EXTERNAL.flatMap((e) => [e.selector, e.offset])
@@ -2619,36 +2636,12 @@ function hashEntryPoint(data) {
   });
   return poseidonHashMany(base);
 }
-function parseHints(hints) {
-  return hints.reduce((cum, [hint_id, hint_codes]) => {
-    cum[hint_id] = hint_codes.map((it) => ({
-      code: it,
-      accessible_scopes: [],
-      flow_tracking_data: { ap_tracking: { group: 0, offset: 0 }, reference_ids: {} }
-    }));
-    return cum;
-  }, {});
-}
-function hintedProgram(casm) {
-  const sortedHintedProgram = sort({
-    program: {
-      prime: casm.prime,
-      data: casm.bytecode,
-      builtins: [],
-      hints: parseHints(casm.hints),
-      compiler_version: casm.compiler_version
-    }
-  });
-  const serialized = formatSpaces(stringify(sortedHintedProgram));
-  return BigInt(addHexPrefix(starkCurve.keccak(utf8ToArray(serialized)).toString(16)));
-}
 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 hintedCompiledClassHash = hintedProgram(casm);
   const bytecode = poseidonHashMany(casm.bytecode.map((it) => BigInt(it)));
   return toHex(
     poseidonHashMany([
@@ -2656,29 +2649,28 @@ function computeCompiledClassHash(casm) {
       externalEntryPointsHash,
       l1Handlers,
       constructor,
-      hintedCompiledClassHash,
       bytecode
     ])
   );
 }
-function hashEntryPointSiera(data) {
+function hashEntryPointSierra(data) {
   const base = data.flatMap((it) => {
     return [BigInt(it.selector), BigInt(it.function_idx)];
   });
   return poseidonHashMany(base);
 }
-function hashAbi(siera) {
-  const indentString = stringify(siera.abi, null, 2);
+function hashAbi(sierra) {
+  const indentString = formatSpaces(stringify2(sierra.abi, null));
   return BigInt(addHexPrefix(starkCurve.keccak(utf8ToArray(indentString)).toString(16)));
 }
-function computeSieraContractClassHash(siera) {
+function computeSierraContractClassHash(sierra) {
   const CONTRACT_CLASS_VERSION = "CONTRACT_CLASS_V0.1.0";
   const compiledClassVersion = BigInt(encodeShortString(CONTRACT_CLASS_VERSION));
-  const externalEntryPointsHash = hashEntryPointSiera(siera.entry_points_by_type.EXTERNAL);
-  const l1Handlers = hashEntryPointSiera(siera.entry_points_by_type.L1_HANDLER);
-  const constructor = hashEntryPointSiera(siera.entry_points_by_type.CONSTRUCTOR);
-  const abiHash = hashAbi(siera);
-  const sieraProgram = poseidonHashMany(siera.sierra_program.map((it) => BigInt(it)));
+  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 = poseidonHashMany(sierra.sierra_program.map((it) => BigInt(it)));
   return toHex(
     poseidonHashMany([
       compiledClassVersion,
@@ -2686,18 +2678,40 @@ function computeSieraContractClassHash(siera) {
       l1Handlers,
       constructor,
       abiHash,
-      sieraProgram
+      sierraProgram
     ])
   );
 }
 function computeContractClassHash(contract) {
-  const compiledContract = typeof contract === "string" ? parse(contract) : contract;
+  const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
   if ("sierra_program" in compiledContract) {
-    return computeSieraContractClassHash(compiledContract);
+    return computeSierraContractClassHash(compiledContract);
   }
   return computeLegacyContractClassHash(compiledContract);
 }
 
+// src/utils/contract.ts
+function isSierra(contract) {
+  const compiledContract = typeof contract === "string" ? parse2(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 = {};
 __export(stark_exports, {
@@ -2714,7 +2728,7 @@ __export(stark_exports, {
 import { Signature, getStarkKey, utils } from "micro-starknet";
 import { gzip } from "pako";
 function compressProgram(jsonProgram) {
-  const stringified = typeof jsonProgram === "string" ? jsonProgram : stringify(jsonProgram);
+  const stringified = typeof jsonProgram === "string" ? jsonProgram : stringify2(jsonProgram);
   const compressedProgram = gzip(stringified);
   return btoaUniversal(compressedProgram);
 }
@@ -2781,12 +2795,23 @@ function parseCalldata(calldata = []) {
     return toHex(data);
   });
 }
+function createSierraContractClass(contract) {
+  const result = { ...contract };
+  delete result.sierra_program_debug_info;
+  result.abi = formatSpaces(stringify2(contract.abi));
+  result.sierra_program = formatSpaces(stringify2(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)
-  };
+  const parsedContract = typeof contract === "string" ? parse2(contract) : contract;
+  if (!isSierra(contract)) {
+    return {
+      ...parsedContract,
+      ..."program" in parsedContract && { program: compressProgram(parsedContract.program) }
+    };
+  }
+  return createSierraContractClass(parsedContract);
 }
 
 // src/utils/responseParser/rpc.ts
@@ -2806,6 +2831,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 || [],
@@ -2828,7 +2854,7 @@ var RPCResponseParser = class {
 };
 
 // src/provider/errors.ts
-import { CustomError } from "ts-custom-error";
+import { CustomError } from "ts-custom-error/dist/custom-error";
 var LibraryError = class extends CustomError {
 };
 var GatewayError = class extends LibraryError {
@@ -3050,7 +3076,7 @@ var RpcProvider = class {
   fetch(method, params) {
     return fetchPonyfill_default(this.nodeUrl, {
       method: "POST",
-      body: stringify({ method, jsonrpc: "2.0", params, id: 0 }),
+      body: stringify2({ method, jsonrpc: "2.0", params, id: 0 }),
       headers: this.headers
     });
   }
@@ -3175,22 +3201,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;
@@ -3212,21 +3241,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", {
@@ -3249,7 +3281,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)
       }
@@ -3358,7 +3390,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,
@@ -3476,24 +3507,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
       }
     };
@@ -3638,20 +3663,20 @@ var SequencerProvider = class {
     try {
       const response = await fetchPonyfill_default(url, {
         method,
-        body: stringify(options == null ? void 0 : options.body),
+        body: stringify2(options == null ? void 0 : options.body),
         headers
       });
       const textResponse = await response.text();
       if (!response.ok) {
         let responseBody;
         try {
-          responseBody = parse(textResponse);
+          responseBody = parse2(textResponse);
         } catch {
           throw new HttpError(response.statusText, response.status);
         }
         throw new GatewayError(responseBody.message, responseBody.code);
       }
-      const parseChoice = (options == null ? void 0 : options.parseAlwaysAsBigInt) ? parseAlwaysAsBig : parse;
+      const parseChoice = (options == null ? void 0 : options.parseAlwaysAsBigInt) ? parseAlwaysAsBig : parse2;
       return parseChoice(textResponse);
     } catch (error) {
       if (error instanceof Error && !(error instanceof LibraryError))
@@ -3667,7 +3692,6 @@ var SequencerProvider = class {
       "call_contract",
       { blockIdentifier },
       {
-        signature: [],
         contract_address: contractAddress,
         entry_point_selector: getSelectorFromName(entryPointSelector),
         calldata
@@ -3712,18 +3736,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) {
@@ -3738,27 +3767,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),
@@ -3766,24 +3807,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),
@@ -3801,7 +3857,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") {
@@ -3880,13 +3936,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),
@@ -3946,11 +4002,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) {
@@ -3980,11 +4037,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);
@@ -3992,8 +4054,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);
@@ -4678,7 +4745,10 @@ var transaction_exports = {};
 __export(transaction_exports, {
   fromCallsToExecuteCalldata: () => fromCallsToExecuteCalldata,
   fromCallsToExecuteCalldataWithNonce: () => fromCallsToExecuteCalldataWithNonce,
-  transformCallsToMulticallArrays: () => transformCallsToMulticallArrays
+  fromCallsToExecuteCalldata_cairo1: () => fromCallsToExecuteCalldata_cairo1,
+  getExecuteCalldata: () => getExecuteCalldata,
+  transformCallsToMulticallArrays: () => transformCallsToMulticallArrays,
+  transformCallsToMulticallArrays_cairo1: () => transformCallsToMulticallArrays_cairo1
 });
 var transformCallsToMulticallArrays = (calls) => {
   const callArray = [];
@@ -4712,6 +4782,27 @@ var fromCallsToExecuteCalldata = (calls) => {
 var fromCallsToExecuteCalldataWithNonce = (calls, nonce) => {
   return [...fromCallsToExecuteCalldata(calls), toBigInt(nonce).toString()];
 };
+var transformCallsToMulticallArrays_cairo1 = (calls) => {
+  const callArray = calls.map((call) => ({
+    to: toBigInt(call.contractAddress).toString(10),
+    selector: toBigInt(getSelectorFromName(call.entrypoint)).toString(10),
+    calldata: bigNumberishArrayToDecimalStringArray(call.calldata || [])
+  }));
+  return callArray;
+};
+var fromCallsToExecuteCalldata_cairo1 = (calls) => {
+  const callArray = transformCallsToMulticallArrays_cairo1(calls);
+  return [
+    callArray.length.toString(),
+    ...callArray.map(({ to, selector, calldata }) => [to, selector, calldata.length.toString(), ...calldata]).flat()
+  ];
+};
+var getExecuteCalldata = (calls, cairoVersion = "0") => {
+  if (cairoVersion === "1") {
+    return fromCallsToExecuteCalldata_cairo1(calls);
+  }
+  return fromCallsToExecuteCalldata(calls);
+};
 
 // src/utils/typedData/index.ts
 var typedData_exports = {};
@@ -4938,7 +5029,7 @@ var Signer = class {
     if (abis && abis.length !== transactions.length) {
       throw new Error("ABI must be provided for each transaction or no transaction");
     }
-    const calldata = fromCallsToExecuteCalldata(transactions);
+    const calldata = getExecuteCalldata(transactions, transactionsDetail.cairoVersion);
     const msgHash = calculateTransactionHash(
       transactionsDetail.walletAddress,
       transactionsDetail.version,
@@ -4971,14 +5062,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);
   }
@@ -5020,7 +5120,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, cairoVersion } = {}) {
     const transactions = Array.isArray(calls) ? calls : [calls];
     const nonce = toBigInt(providedNonce ?? await this.getNonce());
     const version = toBigInt(feeTransactionVersion);
@@ -5030,13 +5130,15 @@ var Account = class extends Provider {
       nonce,
       maxFee: ZERO,
       version,
-      chainId
+      chainId,
+      cairoVersion: cairoVersion ?? "0"
     };
     const invocation = await this.buildInvocation(transactions, signerDetails);
     const response = await super.getInvokeEstimateFee(
       { ...invocation },
       { version, nonce },
-      blockIdentifier
+      blockIdentifier,
+      skipValidate
     );
     const suggestedMaxFee = estimatedFeeToMaxFee(response.overall_fee);
     return {
@@ -5044,18 +5146,26 @@ 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, cairoVersion } = {}) {
     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 },
-      { nonce, chainId, version, walletAddress: this.address, maxFee: ZERO }
+    const declareContractTransaction = await this.buildDeclarePayload(
+      { classHash: providedClassHash, contract, casm, compiledClassHash },
+      {
+        nonce,
+        chainId,
+        version,
+        walletAddress: this.address,
+        maxFee: ZERO,
+        cairoVersion: cairoVersion ?? "0"
+      }
     );
     const response = await super.getDeclareEstimateFee(
-      { ...payload },
+      declareContractTransaction,
       { version, nonce },
-      blockIdentifier
+      blockIdentifier,
+      skipValidate
     );
     const suggestedMaxFee = estimatedFeeToMaxFee(response.overall_fee);
     return {
@@ -5068,18 +5178,26 @@ var Account = class extends Provider {
     addressSalt = 0,
     constructorCalldata = [],
     contractAddress: providedContractAddress
-  }, { blockIdentifier } = {}) {
+  }, { blockIdentifier, skipValidate, cairoVersion } = {}) {
     const version = toBigInt(feeTransactionVersion);
     const nonce = ZERO;
     const chainId = await this.getChainId();
     const payload = await this.buildAccountDeployPayload(
       { classHash, addressSalt, constructorCalldata, contractAddress: providedContractAddress },
-      { nonce, chainId, version, walletAddress: this.address, maxFee: ZERO }
+      {
+        nonce,
+        chainId,
+        version,
+        walletAddress: this.address,
+        maxFee: ZERO,
+        cairoVersion: cairoVersion ?? "0"
+      }
     );
     const response = await super.getDeployAccountEstimateFee(
       { ...payload },
       { version, nonce },
-      blockIdentifier
+      blockIdentifier,
+      skipValidate
     );
     const suggestedMaxFee = estimatedFeeToMaxFee(response.overall_fee);
     return {
@@ -5091,7 +5209,7 @@ var Account = class extends Provider {
     const calls = this.buildUDCContractPayload(payload);
     return this.estimateInvokeFee(calls, transactionsDetail);
   }
-  async estimateFeeBulk(transactions, { nonce: providedNonce, blockIdentifier } = {}) {
+  async estimateFeeBulk(transactions, { nonce: providedNonce, blockIdentifier, cairoVersion } = {}) {
     const nonce = toBigInt(providedNonce ?? await this.getNonce());
     const version = toBigInt(feeTransactionVersion);
     const chainId = await this.getChainId();
@@ -5102,7 +5220,8 @@ var Account = class extends Provider {
           nonce: toBigInt(Number(nonce) + index),
           maxFee: ZERO,
           version,
-          chainId
+          chainId,
+          cairoVersion: cairoVersion ?? "0"
         };
         const txPayload = transaction.payload;
         let res;
@@ -5160,7 +5279,7 @@ var Account = class extends Provider {
     });
   }
   async buildInvocation(call, signerDetails) {
-    const calldata = fromCallsToExecuteCalldata(call);
+    const calldata = getExecuteCalldata(call, signerDetails.cairoVersion);
     const signature = await this.signer.signTransaction(call, signerDetails);
     return {
       contractAddress: this.address,
@@ -5177,15 +5296,17 @@ var Account = class extends Provider {
     );
     const version = toBigInt(transactionVersion);
     const chainId = await this.getChainId();
+    const cairoVersion = transactionsDetail.cairoVersion ?? "0";
     const signerDetails = {
       walletAddress: this.address,
       nonce,
       maxFee,
       version,
-      chainId
+      chainId,
+      cairoVersion
     };
     const signature = await this.signer.signTransaction(transactions, signerDetails, abis);
-    const calldata = fromCallsToExecuteCalldata(transactions);
+    const calldata = getExecuteCalldata(transactions, cairoVersion);
     return this.invokeFunction(
       { contractAddress: this.address, calldata, signature },
       {
@@ -5195,32 +5316,25 @@ 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,
+      cairoVersion: transactionsDetail.cairoVersion ?? "0"
     });
-    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) => {
@@ -5359,13 +5473,14 @@ var Account = class extends Provider {
         feeEstimate = { suggestedMaxFee: ZERO, overall_fee: ZERO };
         break;
     }
-    return feeEstimate.suggestedMaxFee.toString();
+    return feeEstimate.suggestedMaxFee;
   }
-  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,
@@ -5375,7 +5490,8 @@ var Account = class extends Provider {
     return {
       senderAddress: walletAddress,
       signature,
-      contractDefinition
+      contractDefinition,
+      compiledClassHash
     };
   }
   async buildAccountDeployPayload({
@@ -5425,7 +5541,7 @@ var Account = class extends Provider {
     });
     return calls;
   }
-  async simulateTransaction(calls, { nonce: providedNonce, blockIdentifier } = {}) {
+  async simulateTransaction(calls, { nonce: providedNonce, blockIdentifier, skipValidate, cairoVersion } = {}) {
     const transactions = Array.isArray(calls) ? calls : [calls];
     const nonce = toBigInt(providedNonce ?? await this.getNonce());
     const version = toBigInt(feeTransactionVersion);
@@ -5435,13 +5551,15 @@ var Account = class extends Provider {
       nonce,
       maxFee: ZERO,
       version,
-      chainId
+      chainId,
+      cairoVersion: cairoVersion ?? "0"
     };
     const invocation = await this.buildInvocation(transactions, signerDetails);
     const response = await super.getSimulateTransaction(
       invocation,
       { version, nonce },
-      blockIdentifier
+      blockIdentifier,
+      skipValidate
     );
     const suggestedMaxFee = estimatedFeeToMaxFee(response.fee_estimation.overall_fee);
     return {
@@ -5497,9 +5615,11 @@ var number = num_exports;
 export {
   Account,
   AccountInterface,
+  CallData,
   Contract,
   ContractFactory,
   ContractInterface,
+  EntryPointType,
   GatewayError,
   HttpError,
   LibraryError,