starknet 5.9.2 → 5.10.1

package/dist/index.mjs

@@ -50,55 +50,27 @@ function assert(condition, message) {
   }
 }
 
-// src/utils/hash.ts
-var hash_exports = {};
-__export(hash_exports, {
-  calculateContractAddressFromHash: () => calculateContractAddressFromHash,
-  calculateDeclareTransactionHash: () => calculateDeclareTransactionHash,
-  calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash,
-  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_2: () => transactionVersion_2
-});
-import { keccak, poseidonHashMany } from "micro-starknet";
-
-// src/constants.ts
-var constants_exports = {};
-__export(constants_exports, {
-  ALPHA: () => ALPHA,
-  API_VERSION: () => API_VERSION,
-  BETA: () => BETA,
-  BaseUrl: () => BaseUrl,
-  CONSTANT_POINTS: () => CONSTANT_POINTS,
-  EC_ORDER: () => EC_ORDER,
-  FIELD_GEN: () => FIELD_GEN,
-  FIELD_PRIME: () => FIELD_PRIME,
-  FIELD_SIZE: () => FIELD_SIZE,
-  IS_BROWSER: () => IS_BROWSER,
-  MASK_250: () => MASK_250,
-  MASK_251: () => MASK_251,
-  MAX_ECDSA_VAL: () => MAX_ECDSA_VAL,
-  NetworkName: () => NetworkName,
-  StarknetChainId: () => StarknetChainId,
-  TransactionHashPrefix: () => TransactionHashPrefix,
-  UDC: () => UDC,
-  ZERO: () => ZERO
+// src/utils/num.ts
+var num_exports = {};
+__export(num_exports, {
+  assertInRange: () => assertInRange,
+  bigNumberishArrayToDecimalStringArray: () => bigNumberishArrayToDecimalStringArray,
+  bigNumberishArrayToHexadecimalStringArray: () => bigNumberishArrayToHexadecimalStringArray,
+  cleanHex: () => cleanHex,
+  getDecimalString: () => getDecimalString,
+  getHexString: () => getHexString,
+  getHexStringArray: () => getHexStringArray,
+  hexToBytes: () => hexToBytes,
+  hexToDecimalString: () => hexToDecimalString,
+  isBigInt: () => isBigInt,
+  isHex: () => isHex,
+  isStringWholeNumber: () => isStringWholeNumber,
+  toBigInt: () => toBigInt,
+  toCairoBool: () => toCairoBool,
+  toHex: () => toHex,
+  toHexString: () => toHexString
 });
+import { hexToBytes as hexToBytesNoble } from "@noble/curves/abstract/utils";
 
 // src/utils/encode.ts
 var encode_exports = {};
@@ -163,7 +135,98 @@ function utf8ToArray(str) {
   return new TextEncoder().encode(str);
 }
 
+// src/utils/num.ts
+function isHex(hex) {
+  return /^0x[0-9a-f]*$/i.test(hex);
+}
+function toBigInt(value) {
+  return BigInt(value);
+}
+function isBigInt(value) {
+  return typeof value === "bigint";
+}
+function toHex(number2) {
+  return addHexPrefix(toBigInt(number2).toString(16));
+}
+function hexToDecimalString(hex) {
+  return BigInt(addHexPrefix(hex)).toString(10);
+}
+var cleanHex = (hex) => hex.toLowerCase().replace(/^(0x)0+/, "$1");
+function assertInRange(input, lowerBound, upperBound, inputName = "") {
+  const messageSuffix = inputName === "" ? "invalid length" : `invalid ${inputName} length`;
+  const inputBigInt = BigInt(input);
+  const lowerBoundBigInt = BigInt(lowerBound);
+  const upperBoundBigInt = BigInt(upperBound);
+  assert(
+    inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt,
+    `Message not signable, ${messageSuffix}.`
+  );
+}
+function bigNumberishArrayToDecimalStringArray(rawCalldata) {
+  return rawCalldata.map((x) => toBigInt(x).toString(10));
+}
+function bigNumberishArrayToHexadecimalStringArray(rawCalldata) {
+  return rawCalldata.map((x) => toHex(x));
+}
+var isStringWholeNumber = (value) => /^\d+$/.test(value);
+var toHexString = (value) => toHex(value);
+function getDecimalString(value) {
+  if (isHex(value)) {
+    return hexToDecimalString(value);
+  }
+  if (isStringWholeNumber(value)) {
+    return value;
+  }
+  throw new Error(`${value} need to be hex-string or whole-number-string`);
+}
+function getHexString(value) {
+  if (isHex(value)) {
+    return value;
+  }
+  if (isStringWholeNumber(value)) {
+    return toHexString(value);
+  }
+  throw new Error(`${value} need to be hex-string or whole-number-string`);
+}
+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/selector.ts
+import { keccak } from "micro-starknet";
+
 // src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  ALPHA: () => ALPHA,
+  API_VERSION: () => API_VERSION,
+  BETA: () => BETA,
+  BaseUrl: () => BaseUrl,
+  CONSTANT_POINTS: () => CONSTANT_POINTS,
+  EC_ORDER: () => EC_ORDER,
+  FIELD_GEN: () => FIELD_GEN,
+  FIELD_PRIME: () => FIELD_PRIME,
+  FIELD_SIZE: () => FIELD_SIZE,
+  IS_BROWSER: () => IS_BROWSER,
+  MASK_250: () => MASK_250,
+  MASK_251: () => MASK_251,
+  MAX_ECDSA_VAL: () => MAX_ECDSA_VAL,
+  NetworkName: () => NetworkName,
+  StarknetChainId: () => StarknetChainId,
+  TransactionHashPrefix: () => TransactionHashPrefix,
+  UDC: () => UDC,
+  ZERO: () => ZERO
+});
 var ZERO = 0n;
 var MASK_250 = 2n ** 250n - 1n;
 var MASK_251 = 2n ** 251n;
@@ -2232,6 +2295,83 @@ var CONSTANT_POINTS = [
   ]
 ];
 
+// src/utils/selector.ts
+function keccakBn(value) {
+  const hexWithoutPrefix = removeHexPrefix(toHex(BigInt(value)));
+  const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
+  return addHexPrefix(keccak(hexToBytes(addHexPrefix(evenHex))).toString(16));
+}
+function keccakHex(value) {
+  return addHexPrefix(keccak(utf8ToArray(value)).toString(16));
+}
+function starknetKeccak(value) {
+  const hash = BigInt(keccakHex(value));
+  return hash & MASK_250;
+}
+function getSelectorFromName(funcName) {
+  return toHex(starknetKeccak(funcName));
+}
+function getSelector(value) {
+  if (isHex(value)) {
+    return value;
+  }
+  if (isStringWholeNumber(value)) {
+    return toHexString(value);
+  }
+  return getSelectorFromName(value);
+}
+
+// src/utils/shortString.ts
+var shortString_exports = {};
+__export(shortString_exports, {
+  decodeShortString: () => decodeShortString,
+  encodeShortString: () => encodeShortString,
+  isASCII: () => isASCII,
+  isDecimalString: () => isDecimalString,
+  isLongText: () => isLongText,
+  isShortString: () => isShortString,
+  isShortText: () => isShortText,
+  isText: () => isText,
+  splitLongString: () => splitLongString
+});
+var TEXT_TO_FELT_MAX_LEN = 31;
+function isASCII(str) {
+  return /^[\x00-\x7F]*$/.test(str);
+}
+function isShortString(str) {
+  return str.length <= TEXT_TO_FELT_MAX_LEN;
+}
+function isDecimalString(decim) {
+  return /^[0-9]*$/i.test(decim);
+}
+function isText(val) {
+  return typeof val === "string" && !isHex(val) && !isStringWholeNumber(val);
+}
+var isShortText = (val) => isText(val) && isShortString(val);
+var isLongText = (val) => isText(val) && !isShortString(val);
+function splitLongString(longStr) {
+  const regex = RegExp(`[^]{1,${TEXT_TO_FELT_MAX_LEN}}`, "g");
+  return longStr.match(regex) || [];
+}
+function encodeShortString(str) {
+  if (!isASCII(str))
+    throw new Error(`${str} is not an ASCII string`);
+  if (!isShortString(str))
+    throw new Error(`${str} is too long`);
+  return addHexPrefix(str.replace(/./g, (char) => char.charCodeAt(0).toString(16)));
+}
+function decodeShortString(str) {
+  if (!isASCII(str))
+    throw new Error(`${str} is not an ASCII string`);
+  if (isHex(str)) {
+    return removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
+  }
+  if (isDecimalString(str)) {
+    return decodeShortString("0X".concat(BigInt(str).toString(16)));
+  }
+  throw new Error(`${str} is not Hex or decimal`);
+}
+
 // src/utils/calldata/cairo.ts
 var cairo_exports = {};
 __export(cairo_exports, {
@@ -2253,144 +2393,6 @@ __export(cairo_exports, {
   uint256: () => uint256
 });
 
-// src/utils/num.ts
-var num_exports = {};
-__export(num_exports, {
-  assertInRange: () => assertInRange,
-  bigNumberishArrayToDecimalStringArray: () => bigNumberishArrayToDecimalStringArray,
-  bigNumberishArrayToHexadecimalStringArray: () => bigNumberishArrayToHexadecimalStringArray,
-  cleanHex: () => cleanHex,
-  getDecimalString: () => getDecimalString,
-  getHexString: () => getHexString,
-  getHexStringArray: () => getHexStringArray,
-  hexToBytes: () => hexToBytes,
-  hexToDecimalString: () => hexToDecimalString,
-  isBigInt: () => isBigInt,
-  isHex: () => isHex,
-  isStringWholeNumber: () => isStringWholeNumber,
-  toBigInt: () => toBigInt,
-  toCairoBool: () => toCairoBool,
-  toHex: () => toHex,
-  toHexString: () => toHexString
-});
-import { hexToBytes as hexToBytesNoble } from "@noble/curves/abstract/utils";
-function isHex(hex) {
-  return /^0x[0-9a-f]*$/i.test(hex);
-}
-function toBigInt(value) {
-  return BigInt(value);
-}
-function isBigInt(value) {
-  return typeof value === "bigint";
-}
-function toHex(number2) {
-  return addHexPrefix(toBigInt(number2).toString(16));
-}
-function hexToDecimalString(hex) {
-  return BigInt(addHexPrefix(hex)).toString(10);
-}
-var cleanHex = (hex) => hex.toLowerCase().replace(/^(0x)0+/, "$1");
-function assertInRange(input, lowerBound, upperBound, inputName = "") {
-  const messageSuffix = inputName === "" ? "invalid length" : `invalid ${inputName} length`;
-  const inputBigInt = BigInt(input);
-  const lowerBoundBigInt = BigInt(lowerBound);
-  const upperBoundBigInt = BigInt(upperBound);
-  assert(
-    inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt,
-    `Message not signable, ${messageSuffix}.`
-  );
-}
-function bigNumberishArrayToDecimalStringArray(rawCalldata) {
-  return rawCalldata.map((x) => toBigInt(x).toString(10));
-}
-function bigNumberishArrayToHexadecimalStringArray(rawCalldata) {
-  return rawCalldata.map((x) => toHex(x));
-}
-var isStringWholeNumber = (value) => /^\d+$/.test(value);
-var toHexString = (value) => toHex(value);
-function getDecimalString(value) {
-  if (isHex(value)) {
-    return hexToDecimalString(value);
-  }
-  if (isStringWholeNumber(value)) {
-    return value;
-  }
-  throw new Error(`${value} need to be hex-string or whole-number-string`);
-}
-function getHexString(value) {
-  if (isHex(value)) {
-    return value;
-  }
-  if (isStringWholeNumber(value)) {
-    return toHexString(value);
-  }
-  throw new Error(`${value} need to be hex-string or whole-number-string`);
-}
-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 = {};
-__export(shortString_exports, {
-  decodeShortString: () => decodeShortString,
-  encodeShortString: () => encodeShortString,
-  isASCII: () => isASCII,
-  isDecimalString: () => isDecimalString,
-  isLongText: () => isLongText,
-  isShortString: () => isShortString,
-  isShortText: () => isShortText,
-  isText: () => isText,
-  splitLongString: () => splitLongString
-});
-var TEXT_TO_FELT_MAX_LEN = 31;
-function isASCII(str) {
-  return /^[\x00-\x7F]*$/.test(str);
-}
-function isShortString(str) {
-  return str.length <= TEXT_TO_FELT_MAX_LEN;
-}
-function isDecimalString(decim) {
-  return /^[0-9]*$/i.test(decim);
-}
-function isText(val) {
-  return typeof val === "string" && !isHex(val) && !isStringWholeNumber(val);
-}
-var isShortText = (val) => isText(val) && isShortString(val);
-var isLongText = (val) => isText(val) && !isShortString(val);
-function splitLongString(longStr) {
-  const regex = RegExp(`[^]{1,${TEXT_TO_FELT_MAX_LEN}}`, "g");
-  return longStr.match(regex) || [];
-}
-function encodeShortString(str) {
-  if (!isASCII(str))
-    throw new Error(`${str} is not an ASCII string`);
-  if (!isShortString(str))
-    throw new Error(`${str} is too long`);
-  return addHexPrefix(str.replace(/./g, (char) => char.charCodeAt(0).toString(16)));
-}
-function decodeShortString(str) {
-  if (!isASCII(str))
-    throw new Error(`${str} is not an ASCII string`);
-  if (isHex(str)) {
-    return removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
-  }
-  if (isDecimalString(str)) {
-    return decodeShortString("0X".concat(BigInt(str).toString(16)));
-  }
-  throw new Error(`${str} is not Hex or decimal`);
-}
-
 // src/utils/uint256.ts
 var uint256_exports = {};
 __export(uint256_exports, {
@@ -2430,7 +2432,7 @@ var Uint = /* @__PURE__ */ ((Uint2) => {
 })(Uint || {});
 var isLen = (name) => /_len$/.test(name);
 var isTypeFelt = (type) => type === "felt" || type === "core::felt252";
-var isTypeArray = (type) => /\*/.test(type) || type.includes("core::array::Array::");
+var isTypeArray = (type) => /\*/.test(type) || type.startsWith("core::array::Array::");
 var isTypeTuple = (type) => /^\(.*\)$/i.test(type);
 var isTypeNamedTuple = (type) => /\(.*\)/i.test(type) && type.includes(":");
 var isTypeStruct = (type, structs) => type in structs;
@@ -2441,7 +2443,7 @@ var isTypeContractAddress = (type) => type === "core::starknet::contract_address
 var isCairo1Type = (type) => type.includes("core::");
 var getArrayType = (type) => {
   if (isCairo1Type(type)) {
-    return type.substring(type.indexOf("<") + 1, type.indexOf(">"));
+    return type.substring(type.indexOf("<") + 1, type.lastIndexOf(">"));
   }
   return type.replace("*", "");
 };
@@ -2470,271 +2472,13 @@ function felt(it) {
   if (typeof it === "string" && isHex(it)) {
     return BigInt(it).toString();
   }
-  if (typeof it === "string" && isStringWholeNumber(it)) {
-    return it;
-  }
-  if (typeof it === "boolean") {
-    return `${+it}`;
-  }
-  throw new Error(`${it} can't be computed by felt()`);
-}
-
-// src/utils/ec.ts
-var ec_exports = {};
-__export(ec_exports, {
-  starkCurve: () => starkCurve,
-  weierstrass: () => weierstrass
-});
-import * as starkCurve from "micro-starknet";
-import * as weierstrass from "@noble/curves/abstract/weierstrass";
-
-// src/utils/json.ts
-var json_exports = {};
-__export(json_exports, {
-  parse: () => parse2,
-  parseAlwaysAsBig: () => parseAlwaysAsBig,
-  stringify: () => stringify2,
-  stringifyAlwaysAsBig: () => stringifyAlwaysAsBig
-});
-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 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(keccak(hexToBytes(addHexPrefix(evenHex))).toString(16));
-}
-function keccakHex(value) {
-  return addHexPrefix(keccak(utf8ToArray(value)).toString(16));
-}
-function starknetKeccak(value) {
-  const hash = BigInt(keccakHex(value));
-  return hash & MASK_250;
-}
-function getSelectorFromName(funcName) {
-  return toHex(starknetKeccak(funcName));
-}
-function getSelector(value) {
-  if (isHex(value)) {
-    return value;
-  }
-  if (isStringWholeNumber(value)) {
-    return toHexString(value);
-  }
-  return getSelectorFromName(value);
-}
-function computeHashOnElements(data) {
-  return [...data, data.length].reduce((x, y) => starkCurve.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
-}
-function calculateTransactionHashCommon(txHashPrefix, version, contractAddress, entryPointSelector, calldata, maxFee, chainId, additionalData = []) {
-  const calldataHash = computeHashOnElements(calldata);
-  const dataToHash = [
-    txHashPrefix,
-    version,
-    contractAddress,
-    entryPointSelector,
-    calldataHash,
-    maxFee,
-    chainId,
-    ...additionalData
-  ];
-  return computeHashOnElements(dataToHash);
-}
-function calculateDeployTransactionHash(contractAddress, constructorCalldata, version, chainId) {
-  return calculateTransactionHashCommon(
-    "0x6465706c6f79" /* DEPLOY */,
-    version,
-    contractAddress,
-    getSelectorFromName("constructor"),
-    constructorCalldata,
-    0,
-    chainId
-  );
-}
-function calculateDeclareTransactionHash(classHash, senderAddress, version, maxFee, chainId, nonce, compiledClassHash) {
-  return calculateTransactionHashCommon(
-    "0x6465636c617265" /* DECLARE */,
-    version,
-    senderAddress,
-    0,
-    [classHash],
-    maxFee,
-    chainId,
-    [nonce, ...compiledClassHash ? [compiledClassHash] : []]
-  );
-}
-function calculateDeployAccountTransactionHash(contractAddress, classHash, constructorCalldata, salt, version, maxFee, chainId, nonce) {
-  const calldata = [classHash, salt, ...constructorCalldata];
-  return calculateTransactionHashCommon(
-    "0x6465706c6f795f6163636f756e74" /* DEPLOY_ACCOUNT */,
-    version,
-    contractAddress,
-    0,
-    calldata,
-    maxFee,
-    chainId,
-    [nonce]
-  );
-}
-function calculateTransactionHash(contractAddress, version, calldata, maxFee, chainId, nonce) {
-  return calculateTransactionHashCommon(
-    "0x696e766f6b65" /* INVOKE */,
-    version,
-    contractAddress,
-    0,
-    calldata,
-    maxFee,
-    chainId,
-    [nonce]
-  );
-}
-function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
-  const constructorCalldataHash = computeHashOnElements(constructorCalldata);
-  const CONTRACT_ADDRESS_PREFIX = felt("0x535441524b4e45545f434f4e54524143545f41444452455353");
-  return computeHashOnElements([
-    CONTRACT_ADDRESS_PREFIX,
-    deployerAddress,
-    salt,
-    classHash,
-    constructorCalldataHash
-  ]);
-}
-function nullSkipReplacer(key, value) {
-  if (key === "attributes" || key === "accessible_scopes") {
-    return Array.isArray(value) && value.length === 0 ? void 0 : value;
-  }
-  if (key === "debug_info") {
-    return null;
-  }
-  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 serializedJson = formatSpaces(stringify2(contractClass, nullSkipReplacer));
-  return addHexPrefix(starkCurve.keccak(utf8ToArray(serializedJson)).toString(16));
-}
-function computeLegacyContractClassHash(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])
-  );
-  const l1HandlerEntryPointsHash = computeHashOnElements(
-    compiledContract.entry_points_by_type.L1_HANDLER.flatMap((e) => [e.selector, e.offset])
-  );
-  const constructorEntryPointHash = computeHashOnElements(
-    compiledContract.entry_points_by_type.CONSTRUCTOR.flatMap((e) => [e.selector, e.offset])
-  );
-  const builtinsHash = computeHashOnElements(
-    compiledContract.program.builtins.map((s) => encodeShortString(s))
-  );
-  const hintedClassHash = computeHintedClassHash(compiledContract);
-  const dataHash = computeHashOnElements(compiledContract.program.data);
-  return computeHashOnElements([
-    apiVersion,
-    externalEntryPointsHash,
-    l1HandlerEntryPointsHash,
-    constructorEntryPointHash,
-    builtinsHash,
-    hintedClassHash,
-    dataHash
-  ]);
-}
-function hashBuiltins(builtins) {
-  return 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 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 = poseidonHashMany(casm.bytecode.map((it) => BigInt(it)));
-  return toHex(
-    poseidonHashMany([
-      compiledClassVersion,
-      externalEntryPointsHash,
-      l1Handlers,
-      constructor,
-      bytecode
-    ])
-  );
-}
-function hashEntryPointSierra(data) {
-  const base = data.flatMap((it) => {
-    return [BigInt(it.selector), BigInt(it.function_idx)];
-  });
-  return poseidonHashMany(base);
-}
-function hashAbi(sierra) {
-  const indentString = formatSpaces(stringify2(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 = poseidonHashMany(sierra.sierra_program.map((it) => BigInt(it)));
-  return toHex(
-    poseidonHashMany([
-      compiledClassVersion,
-      externalEntryPointsHash,
-      l1Handlers,
-      constructor,
-      abiHash,
-      sierraProgram
-    ])
-  );
-}
-function computeContractClassHash(contract) {
-  const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
-  if ("sierra_program" in compiledContract) {
-    return computeSierraContractClassHash(compiledContract);
-  }
-  return computeLegacyContractClassHash(compiledContract);
+  if (typeof it === "string" && isStringWholeNumber(it)) {
+    return it;
+  }
+  if (typeof it === "boolean") {
+    return `${+it}`;
+  }
+  throw new Error(`${it} can't be computed by felt()`);
 }
 
 // src/utils/calldata/formatter.ts
@@ -2885,7 +2629,12 @@ function parseCalldataValue(element, type, structs) {
     throw Error(`Missing parameter for type ${type}`);
   }
   if (Array.isArray(element)) {
-    throw Error(`Array inside array (nD) are not supported by cairo. Element: ${element} ${type}`);
+    const result = [];
+    result.push(felt(element.length));
+    const arrayType = getArrayType(type);
+    return element.reduce((acc, it) => {
+      return acc.concat(parseCalldataValue(it, arrayType, structs));
+    }, result);
   }
   if (structs[type] && structs[type].members.length) {
     const { members } = structs[type];
@@ -2917,17 +2666,7 @@ function parseCalldataField(argsIterator, input, structs) {
       if (typeof value === "string") {
         value = splitLongString(value);
       }
-      const result = [];
-      result.push(felt(value.length));
-      const arrayType = getArrayType(input.type);
-      return value.reduce((acc, el) => {
-        if (isTypeStruct(arrayType, structs) || isTypeTuple(arrayType) || isTypeArray(arrayType)) {
-          acc.push(...parseCalldataValue(el, arrayType, structs));
-        } else {
-          return acc.concat(parseBaseTypes(arrayType, el));
-        }
-        return acc;
-      }, result);
+      return parseCalldataValue(value, input.type, structs);
     case (isTypeStruct(type, structs) || isTypeTuple(type)):
       return parseCalldataValue(value, type, structs);
     case isTypeUint256(type):
@@ -2957,23 +2696,33 @@ function parseBaseTypes2(type, it) {
       return BigInt(temp);
   }
 }
-function parseResponseStruct(responseIterator, type, structs) {
-  if (type in structs && structs[type]) {
-    return structs[type].members.reduce((acc, el) => {
-      acc[el.name] = parseResponseStruct(responseIterator, el.type, structs);
+function parseResponseValue(responseIterator, element, structs) {
+  if (element.type in structs && structs[element.type]) {
+    return structs[element.type].members.reduce((acc, el) => {
+      acc[el.name] = parseResponseValue(responseIterator, el, structs);
       return acc;
     }, {});
   }
-  if (isTypeTuple(type)) {
-    const memberTypes = extractTupleMemberTypes(type);
+  if (isTypeTuple(element.type)) {
+    const memberTypes = extractTupleMemberTypes(element.type);
     return memberTypes.reduce((acc, it, idx) => {
-      const tName = (it == null ? void 0 : it.name) ? it.name : idx;
-      const tType = (it == null ? void 0 : it.type) ? it.type : it;
-      acc[tName] = parseResponseStruct(responseIterator, tType, structs);
+      const name = (it == null ? void 0 : it.name) ? it.name : idx;
+      const type = (it == null ? void 0 : it.type) ? it.type : it;
+      const el = { name, type };
+      acc[name] = parseResponseValue(responseIterator, el, structs);
       return acc;
     }, {});
   }
-  return parseBaseTypes2(type, responseIterator);
+  if (isTypeArray(element.type)) {
+    const parsedDataArr = [];
+    const el = { name: "", type: getArrayType(element.type) };
+    const len = BigInt(responseIterator.next().value);
+    while (parsedDataArr.length < len) {
+      parsedDataArr.push(parseResponseValue(responseIterator, el, structs));
+    }
+    return parsedDataArr;
+  }
+  return parseBaseTypes2(element.type, responseIterator);
 }
 function responseParser(responseIterator, output, structs, parsedResult) {
   const { name, type } = output;
@@ -2982,27 +2731,26 @@ function responseParser(responseIterator, output, structs, parsedResult) {
     case isLen(name):
       temp = responseIterator.next().value;
       return BigInt(temp);
+    case (type in structs || isTypeTuple(type)):
+      return parseResponseValue(responseIterator, output, structs);
     case isTypeArray(type):
-      const parsedDataArr = [];
       if (isCairo1Type(type)) {
-        const arrayType = getArrayType(type);
-        const len = BigInt(responseIterator.next().value);
-        while (parsedDataArr.length < len) {
-          parsedDataArr.push(parseResponseStruct(responseIterator, arrayType, structs));
-        }
-        return parsedDataArr;
+        return parseResponseValue(responseIterator, output, structs);
       }
+      const parsedDataArr = [];
       if (parsedResult && parsedResult[`${name}_len`]) {
         const arrLen = parsedResult[`${name}_len`];
         while (parsedDataArr.length < arrLen) {
           parsedDataArr.push(
-            parseResponseStruct(responseIterator, output.type.replace("*", ""), structs)
+            parseResponseValue(
+              responseIterator,
+              { name, type: output.type.replace("*", "") },
+              structs
+            )
           );
         }
       }
       return parsedDataArr;
-    case (type in structs || isTypeTuple(type)):
-      return parseResponseStruct(responseIterator, type, structs);
     default:
       return parseBaseTypes2(type, responseIterator);
   }
@@ -3115,6 +2863,11 @@ var validateArray = (parameter, input, structs) => {
     case isTypeBool(baseType):
       parameter.forEach((param) => validateBool(param, input));
       break;
+    case isTypeArray(baseType):
+      parameter.forEach(
+        (param) => validateArray(param, { name: "", type: baseType }, structs)
+      );
+      break;
     default:
       throw new Error(
         `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
@@ -3155,120 +2908,382 @@ function validateFields(abiMethod, args, structs) {
     return acc + 1;
   }, 0);
 }
-
-// src/utils/calldata/index.ts
-var CallData = class {
-  constructor(abi) {
-    this.abi = abi;
-    this.structs = CallData.getAbiStruct(abi);
-  }
-  validate(type, method, args = []) {
-    if (type !== "DEPLOY") {
-      const invocableFunctionNames = this.abi.filter((abi) => {
-        if (abi.type !== "function")
-          return false;
-        const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
-        return type === "INVOKE" ? !isView : isView;
-      }).map((abi) => abi.name);
-      assert(
-        invocableFunctionNames.includes(method),
-        `${type === "INVOKE" ? "invocable" : "viewable"} method not found in abi`
-      );
-    }
-    const abiMethod = this.abi.find(
-      (abi) => type === "DEPLOY" ? abi.name === method && abi.type === method : abi.name === method && abi.type === "function"
-    );
-    const inputsLength = CallData.abiInputsLength(abiMethod.inputs);
-    if (args.length !== inputsLength) {
-      throw Error(
-        `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
-      );
-    }
-    validateFields(abiMethod, args, this.structs);
+
+// src/utils/calldata/index.ts
+var CallData = class {
+  constructor(abi) {
+    this.abi = abi;
+    this.structs = CallData.getAbiStruct(abi);
+  }
+  validate(type, method, args = []) {
+    if (type !== "DEPLOY") {
+      const invocableFunctionNames = this.abi.filter((abi) => {
+        if (abi.type !== "function")
+          return false;
+        const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
+        return type === "INVOKE" ? !isView : isView;
+      }).map((abi) => abi.name);
+      assert(
+        invocableFunctionNames.includes(method),
+        `${type === "INVOKE" ? "invocable" : "viewable"} method not found in abi`
+      );
+    }
+    const abiMethod = this.abi.find(
+      (abi) => type === "DEPLOY" ? abi.name === method && abi.type === method : abi.name === method && abi.type === "function"
+    );
+    const inputsLength = CallData.abiInputsLength(abiMethod.inputs);
+    if (args.length !== inputsLength) {
+      throw Error(
+        `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
+      );
+    }
+    validateFields(abiMethod, args, this.structs);
+  }
+  compile(method, args) {
+    const argsIterator = args[Symbol.iterator]();
+    const { inputs } = this.abi.find((abi) => abi.name === method);
+    return inputs.reduce(
+      (acc, input) => isLen(input.name) ? acc : acc.concat(parseCalldataField(argsIterator, input, this.structs)),
+      []
+    );
+  }
+  static compile(rawArgs) {
+    const createTree = (obj) => {
+      const getEntries = (o, prefix = "") => {
+        const oe = Array.isArray(o) ? [o.length.toString(), ...o] : o;
+        return Object.entries(oe).flatMap(([k, v]) => {
+          let value = v;
+          if (isLongText(value))
+            value = splitLongString(value);
+          if (k === "entrypoint")
+            value = getSelectorFromName(value);
+          const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
+          if (isBigInt(value))
+            return [[`${prefix}${kk}`, felt(value)]];
+          return Object(value) === value ? getEntries(value, `${prefix}${kk}.`) : [[`${prefix}${kk}`, felt(value)]];
+        });
+      };
+      return Object.fromEntries(getEntries(obj));
+    };
+    let callTreeArray;
+    if (!Array.isArray(rawArgs)) {
+      const callTree = createTree(rawArgs);
+      callTreeArray = Object.values(callTree);
+    } else {
+      const callObj = { ...rawArgs };
+      const callTree = createTree(callObj);
+      callTreeArray = Object.values(callTree);
+    }
+    Object.defineProperty(callTreeArray, "__compiled__", {
+      enumerable: false,
+      writable: false,
+      value: true
+    });
+    return callTreeArray;
+  }
+  parse(method, response) {
+    const { outputs } = this.abi.find((abi) => abi.name === method);
+    const responseIterator = response.flat()[Symbol.iterator]();
+    const parsed = outputs.flat().reduce((acc, output, idx) => {
+      const propName = output.name ?? idx;
+      acc[propName] = responseParser(responseIterator, output, this.structs, acc);
+      if (acc[propName] && acc[`${propName}_len`]) {
+        delete acc[`${propName}_len`];
+      }
+      return acc;
+    }, {});
+    return Object.keys(parsed).length === 1 && 0 in parsed ? parsed[0] : parsed;
+  }
+  format(method, response, format) {
+    const parsed = this.parse(method, response);
+    return formatter(parsed, format);
+  }
+  static abiInputsLength(inputs) {
+    return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
+  }
+  static getAbiStruct(abi) {
+    return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
+      (acc, abiEntry) => ({
+        ...acc,
+        [abiEntry.name]: abiEntry
+      }),
+      {}
+    );
+  }
+  static toCalldata(rawCalldata = []) {
+    return CallData.compile(rawCalldata);
+  }
+  static toHex(raw = []) {
+    const calldata = CallData.compile(raw);
+    return calldata.map((it) => toHex(it));
+  }
+};
+
+// src/utils/fetchPonyfill.ts
+import isomorphicFetch from "isomorphic-fetch";
+var fetchPonyfill_default = typeof window !== "undefined" && window.fetch || typeof global !== "undefined" && global.fetch || isomorphicFetch;
+
+// src/utils/hash.ts
+var hash_exports = {};
+__export(hash_exports, {
+  calculateContractAddressFromHash: () => calculateContractAddressFromHash,
+  calculateDeclareTransactionHash: () => calculateDeclareTransactionHash,
+  calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash,
+  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_2: () => transactionVersion_2
+});
+import { poseidonHashMany } from "micro-starknet";
+
+// src/utils/ec.ts
+var ec_exports = {};
+__export(ec_exports, {
+  starkCurve: () => starkCurve,
+  weierstrass: () => weierstrass
+});
+import * as starkCurve from "micro-starknet";
+import * as weierstrass from "@noble/curves/abstract/weierstrass";
+
+// src/utils/json.ts
+var json_exports = {};
+__export(json_exports, {
+  parse: () => parse2,
+  parseAlwaysAsBig: () => parseAlwaysAsBig,
+  stringify: () => stringify2,
+  stringifyAlwaysAsBig: () => stringifyAlwaysAsBig
+});
+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 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 computeHashOnElements(data) {
+  return [...data, data.length].reduce((x, y) => starkCurve.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
+}
+function calculateTransactionHashCommon(txHashPrefix, version, contractAddress, entryPointSelector, calldata, maxFee, chainId, additionalData = []) {
+  const calldataHash = computeHashOnElements(calldata);
+  const dataToHash = [
+    txHashPrefix,
+    version,
+    contractAddress,
+    entryPointSelector,
+    calldataHash,
+    maxFee,
+    chainId,
+    ...additionalData
+  ];
+  return computeHashOnElements(dataToHash);
+}
+function calculateDeployTransactionHash(contractAddress, constructorCalldata, version, chainId) {
+  return calculateTransactionHashCommon(
+    "0x6465706c6f79" /* DEPLOY */,
+    version,
+    contractAddress,
+    getSelectorFromName("constructor"),
+    constructorCalldata,
+    0,
+    chainId
+  );
+}
+function calculateDeclareTransactionHash(classHash, senderAddress, version, maxFee, chainId, nonce, compiledClassHash) {
+  return calculateTransactionHashCommon(
+    "0x6465636c617265" /* DECLARE */,
+    version,
+    senderAddress,
+    0,
+    [classHash],
+    maxFee,
+    chainId,
+    [nonce, ...compiledClassHash ? [compiledClassHash] : []]
+  );
+}
+function calculateDeployAccountTransactionHash(contractAddress, classHash, constructorCalldata, salt, version, maxFee, chainId, nonce) {
+  const calldata = [classHash, salt, ...constructorCalldata];
+  return calculateTransactionHashCommon(
+    "0x6465706c6f795f6163636f756e74" /* DEPLOY_ACCOUNT */,
+    version,
+    contractAddress,
+    0,
+    calldata,
+    maxFee,
+    chainId,
+    [nonce]
+  );
+}
+function calculateTransactionHash(contractAddress, version, calldata, maxFee, chainId, nonce) {
+  return calculateTransactionHashCommon(
+    "0x696e766f6b65" /* INVOKE */,
+    version,
+    contractAddress,
+    0,
+    calldata,
+    maxFee,
+    chainId,
+    [nonce]
+  );
+}
+function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
+  const compiledCalldata = CallData.compile(constructorCalldata);
+  const constructorCalldataHash = computeHashOnElements(compiledCalldata);
+  const CONTRACT_ADDRESS_PREFIX = felt("0x535441524b4e45545f434f4e54524143545f41444452455353");
+  return computeHashOnElements([
+    CONTRACT_ADDRESS_PREFIX,
+    deployerAddress,
+    salt,
+    classHash,
+    constructorCalldataHash
+  ]);
+}
+function nullSkipReplacer(key, value) {
+  if (key === "attributes" || key === "accessible_scopes") {
+    return Array.isArray(value) && value.length === 0 ? void 0 : value;
   }
-  compile(method, args) {
-    const argsIterator = args[Symbol.iterator]();
-    const { inputs } = this.abi.find((abi) => abi.name === method);
-    return inputs.reduce(
-      (acc, input) => isLen(input.name) ? acc : acc.concat(parseCalldataField(argsIterator, input, this.structs)),
-      []
-    );
+  if (key === "debug_info") {
+    return null;
   }
-  static compile(rawArgs) {
-    const createTree = (obj) => {
-      const getEntries = (o, prefix = "") => {
-        const oe = Array.isArray(o) ? [o.length.toString(), ...o] : o;
-        return Object.entries(oe).flatMap(([k, v]) => {
-          let value = v;
-          if (isLongText(value))
-            value = splitLongString(value);
-          if (k === "entrypoint")
-            value = getSelectorFromName(value);
-          const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
-          if (isBigInt(value))
-            return [[`${prefix}${kk}`, felt(value)]];
-          return Object(value) === value ? getEntries(value, `${prefix}${kk}.`) : [[`${prefix}${kk}`, felt(value)]];
-        });
-      };
-      return Object.fromEntries(getEntries(obj));
-    };
-    let callTreeArray;
-    if (!Array.isArray(rawArgs)) {
-      const callTree = createTree(rawArgs);
-      callTreeArray = Object.values(callTree);
+  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 {
-      const callObj = { ...rawArgs };
-      const callTree = createTree(callObj);
-      callTreeArray = Object.values(callTree);
+      newString += char === ":" ? ": " : char === "," ? ", " : char;
     }
-    Object.defineProperty(callTreeArray, "__compiled__", {
-      enumerable: false,
-      writable: false,
-      value: true
-    });
-    return callTreeArray;
-  }
-  parse(method, response) {
-    const { outputs } = this.abi.find((abi) => abi.name === method);
-    const responseIterator = response.flat()[Symbol.iterator]();
-    const parsed = outputs.flat().reduce((acc, output, idx) => {
-      const propName = output.name ?? idx;
-      acc[propName] = responseParser(responseIterator, output, this.structs, acc);
-      if (acc[propName] && acc[`${propName}_len`]) {
-        delete acc[`${propName}_len`];
-      }
-      return acc;
-    }, {});
-    return Object.keys(parsed).length === 1 && 0 in parsed ? parsed[0] : parsed;
-  }
-  format(method, response, format) {
-    const parsed = this.parse(method, response);
-    return formatter(parsed, format);
-  }
-  static abiInputsLength(inputs) {
-    return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
-  }
-  static getAbiStruct(abi) {
-    return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
-      (acc, abiEntry) => ({
-        ...acc,
-        [abiEntry.name]: abiEntry
-      }),
-      {}
-    );
   }
-  static toCalldata(rawCalldata = []) {
-    return CallData.compile(rawCalldata);
-  }
-  static toHex(rawCalldata = []) {
-    const calldata = CallData.compile(rawCalldata);
-    return calldata.map((it) => toHex(it));
+  return newString;
+}
+function computeHintedClassHash(compiledContract) {
+  const { abi, program } = compiledContract;
+  const contractClass = { abi, program };
+  const serializedJson = formatSpaces(stringify2(contractClass, nullSkipReplacer));
+  return addHexPrefix(starkCurve.keccak(utf8ToArray(serializedJson)).toString(16));
+}
+function computeLegacyContractClassHash(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])
+  );
+  const l1HandlerEntryPointsHash = computeHashOnElements(
+    compiledContract.entry_points_by_type.L1_HANDLER.flatMap((e) => [e.selector, e.offset])
+  );
+  const constructorEntryPointHash = computeHashOnElements(
+    compiledContract.entry_points_by_type.CONSTRUCTOR.flatMap((e) => [e.selector, e.offset])
+  );
+  const builtinsHash = computeHashOnElements(
+    compiledContract.program.builtins.map((s) => encodeShortString(s))
+  );
+  const hintedClassHash = computeHintedClassHash(compiledContract);
+  const dataHash = computeHashOnElements(compiledContract.program.data);
+  return computeHashOnElements([
+    apiVersion,
+    externalEntryPointsHash,
+    l1HandlerEntryPointsHash,
+    constructorEntryPointHash,
+    builtinsHash,
+    hintedClassHash,
+    dataHash
+  ]);
+}
+function hashBuiltins(builtins) {
+  return 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 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 = poseidonHashMany(casm.bytecode.map((it) => BigInt(it)));
+  return toHex(
+    poseidonHashMany([
+      compiledClassVersion,
+      externalEntryPointsHash,
+      l1Handlers,
+      constructor,
+      bytecode
+    ])
+  );
+}
+function hashEntryPointSierra(data) {
+  const base = data.flatMap((it) => {
+    return [BigInt(it.selector), BigInt(it.function_idx)];
+  });
+  return poseidonHashMany(base);
+}
+function hashAbi(sierra) {
+  const indentString = formatSpaces(stringify2(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 = poseidonHashMany(sierra.sierra_program.map((it) => BigInt(it)));
+  return toHex(
+    poseidonHashMany([
+      compiledClassVersion,
+      externalEntryPointsHash,
+      l1Handlers,
+      constructor,
+      abiHash,
+      sierraProgram
+    ])
+  );
+}
+function computeContractClassHash(contract) {
+  const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
+  if ("sierra_program" in compiledContract) {
+    return computeSierraContractClassHash(compiledContract);
   }
-};
-
-// src/utils/fetchPonyfill.ts
-import isomorphicFetch from "isomorphic-fetch";
-var fetchPonyfill_default = typeof window !== "undefined" && window.fetch || typeof global !== "undefined" && global.fetch || isomorphicFetch;
+  return computeLegacyContractClassHash(compiledContract);
+}
 
 // src/utils/contract.ts
 function isSierra(contract) {
@@ -3807,7 +3822,7 @@ var RpcProvider = class {
     return this.fetchEndpoint("starknet_estimateFee", {
       request: {
         type: RPC.TransactionType.DEPLOY_ACCOUNT,
-        constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata || []),
+        constructor_calldata: CallData.toHex(constructorCalldata || []),
         class_hash: toHex(classHash),
         contract_address_salt: toHex(addressSalt || 0),
         signature: signatureToHexArray(signature),
@@ -3844,7 +3859,7 @@ var RpcProvider = class {
   async deployAccountContract({ classHash, constructorCalldata, addressSalt, signature }, details) {
     return this.fetchEndpoint("starknet_addDeployAccountTransaction", {
       deploy_account_transaction: {
-        constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata || []),
+        constructor_calldata: CallData.toHex(constructorCalldata || []),
         class_hash: toHex(classHash),
         contract_address_salt: toHex(addressSalt || 0),
         type: RPC.TransactionType.DEPLOY_ACCOUNT,
@@ -4282,7 +4297,7 @@ var SequencerProvider = class {
       {
         contract_address: contractAddress,
         entry_point_selector: getSelectorFromName(entryPointSelector),
-        calldata
+        calldata: CallData.compile(calldata)
       }
     ).then(this.responseParser.parseCallContractResponse);
   }
@@ -4396,7 +4411,7 @@ var SequencerProvider = class {
       {
         type: "INVOKE_FUNCTION" /* INVOKE */,
         sender_address: invocation.contractAddress,
-        calldata: invocation.calldata ?? [],
+        calldata: CallData.compile(invocation.calldata ?? []),
         signature: signatureToDecimalArray(invocation.signature),
         version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
         nonce: toHex(invocationDetails.nonce)
@@ -4454,7 +4469,7 @@ var SequencerProvider = class {
         res = {
           type: invocation.type,
           sender_address: invocation.contractAddress,
-          calldata: invocation.calldata ?? []
+          calldata: CallData.compile(invocation.calldata ?? [])
         };
       } else if (invocation.type === "DECLARE") {
         res = {
@@ -4537,7 +4552,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       {
         type: "INVOKE_FUNCTION",
         sender_address: invocation.contractAddress,
-        calldata: invocation.calldata ?? [],
+        calldata: CallData.compile(invocation.calldata ?? []),
         signature: signatureToDecimalArray(invocation.signature),
         version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
         nonce: toHex(invocationDetails.nonce),
@@ -4950,7 +4965,7 @@ var transformCallsToMulticallArrays = (calls) => {
   const callArray = [];
   const calldata = [];
   calls.forEach((call) => {
-    const data = call.calldata || [];
+    const data = CallData.compile(call.calldata || []);
     callArray.push({
       to: toBigInt(call.contractAddress).toString(10),
       selector: toBigInt(getSelectorFromName(call.entrypoint)).toString(10),
@@ -4981,11 +4996,16 @@ var transformCallsToMulticallArrays_cairo1 = (calls) => {
   return callArray;
 };
 var fromCallsToExecuteCalldata_cairo1 = (calls) => {
-  return CallData.compile({ calls });
+  const orderCalls = calls.map((call) => ({
+    contractAddress: call.contractAddress,
+    entrypoint: call.entrypoint,
+    calldata: call.calldata
+  }));
+  return CallData.compile({ orderCalls });
 };
 var getExecuteCalldata = (calls, cairoVersion = "0") => {
   if (cairoVersion === "1") {
-    return CallData.compile({ calls });
+    return fromCallsToExecuteCalldata_cairo1(calls);
   }
   return fromCallsToExecuteCalldata(calls);
 };
@@ -5239,7 +5259,7 @@ var Signer = class {
     const msgHash = calculateDeployAccountTransactionHash(
       contractAddress,
       classHash,
-      constructorCalldata,
+      CallData.compile(constructorCalldata),
       addressSalt,
       version,
       maxFee,
@@ -5295,10 +5315,12 @@ function parseUDCEvent(txReceipt) {
 
 // src/account/default.ts
 var Account = class extends Provider {
-  constructor(providerOrOptions, address, pkOrSigner) {
+  constructor(providerOrOptions, address, pkOrSigner, cairoVersion = "0") {
     super(providerOrOptions);
+    this.deploySelf = this.deployAccount;
     this.address = address.toLowerCase();
     this.signer = typeof pkOrSigner === "string" || pkOrSigner instanceof Uint8Array ? new Signer(pkOrSigner) : pkOrSigner;
+    this.cairoVersion = cairoVersion;
   }
   async getNonce(blockIdentifier) {
     return super.getNonceForAddress(this.address, blockIdentifier);
@@ -5306,7 +5328,7 @@ var Account = class extends Provider {
   async estimateFee(calls, estimateFeeDetails) {
     return this.estimateInvokeFee(calls, estimateFeeDetails);
   }
-  async estimateInvokeFee(calls, { nonce: providedNonce, blockIdentifier, skipValidate, cairoVersion } = {}) {
+  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);
@@ -5317,7 +5339,7 @@ var Account = class extends Provider {
       maxFee: ZERO,
       version,
       chainId,
-      cairoVersion: cairoVersion ?? "0"
+      cairoVersion: this.cairoVersion
     };
     const invocation = await this.buildInvocation(transactions, signerDetails);
     const response = await super.getInvokeEstimateFee(
@@ -5332,7 +5354,7 @@ var Account = class extends Provider {
       suggestedMaxFee
     };
   }
-  async estimateDeclareFee({ contract, classHash: providedClassHash, casm, compiledClassHash }, { blockIdentifier, nonce: providedNonce, skipValidate, cairoVersion } = {}) {
+  async estimateDeclareFee({ contract, classHash: providedClassHash, casm, compiledClassHash }, { blockIdentifier, nonce: providedNonce, skipValidate } = {}) {
     const nonce = toBigInt(providedNonce ?? await this.getNonce());
     const version = !isSierra(contract) ? toBigInt(feeTransactionVersion) : transactionVersion_2;
     const chainId = await this.getChainId();
@@ -5344,7 +5366,7 @@ var Account = class extends Provider {
         version,
         walletAddress: this.address,
         maxFee: ZERO,
-        cairoVersion: cairoVersion ?? "0"
+        cairoVersion: this.cairoVersion
       }
     );
     const response = await super.getDeclareEstimateFee(
@@ -5364,7 +5386,7 @@ var Account = class extends Provider {
     addressSalt = 0,
     constructorCalldata = [],
     contractAddress: providedContractAddress
-  }, { blockIdentifier, skipValidate, cairoVersion } = {}) {
+  }, { blockIdentifier, skipValidate } = {}) {
     const version = toBigInt(feeTransactionVersion);
     const nonce = ZERO;
     const chainId = await this.getChainId();
@@ -5376,7 +5398,7 @@ var Account = class extends Provider {
         version,
         walletAddress: this.address,
         maxFee: ZERO,
-        cairoVersion: cairoVersion ?? "0"
+        cairoVersion: this.cairoVersion
       }
     );
     const response = await super.getDeployAccountEstimateFee(
@@ -5395,7 +5417,7 @@ var Account = class extends Provider {
     const calls = this.buildUDCContractPayload(payload);
     return this.estimateInvokeFee(calls, transactionsDetail);
   }
-  async estimateFeeBulk(transactions, { nonce: providedNonce, blockIdentifier, cairoVersion } = {}) {
+  async estimateFeeBulk(transactions, { nonce: providedNonce, blockIdentifier } = {}) {
     const nonce = toBigInt(providedNonce ?? await this.getNonce());
     const version = toBigInt(feeTransactionVersion);
     const chainId = await this.getChainId();
@@ -5407,7 +5429,7 @@ var Account = class extends Provider {
           maxFee: ZERO,
           version,
           chainId,
-          cairoVersion: cairoVersion ?? "0"
+          cairoVersion: this.cairoVersion
         };
         const txPayload = transaction.payload;
         let res;
@@ -5465,7 +5487,7 @@ var Account = class extends Provider {
     });
   }
   async buildInvocation(call, signerDetails) {
-    const calldata = getExecuteCalldata(call, signerDetails.cairoVersion);
+    const calldata = getExecuteCalldata(call, this.cairoVersion);
     const signature = await this.signer.signTransaction(call, signerDetails);
     return {
       contractAddress: this.address,
@@ -5482,17 +5504,16 @@ 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,
-      cairoVersion
+      cairoVersion: this.cairoVersion
     };
     const signature = await this.signer.signTransaction(transactions, signerDetails, abis);
-    const calldata = getExecuteCalldata(transactions, cairoVersion);
+    const calldata = getExecuteCalldata(transactions, this.cairoVersion);
     return this.invokeFunction(
       { contractAddress: this.address, calldata, signature },
       {
@@ -5502,6 +5523,18 @@ var Account = class extends Provider {
       }
     );
   }
+  async declareIfNot(payload, transactionsDetail = {}) {
+    const declareContractPayload = extractContractHashes(payload);
+    try {
+      await this.getClassByHash(declareContractPayload.classHash);
+    } catch (error) {
+      return this.declare(payload, transactionsDetail);
+    }
+    return {
+      transaction_hash: "",
+      class_hash: declareContractPayload.classHash
+    };
+  }
   async declare(payload, transactionsDetail = {}) {
     const declareContractPayload = extractContractHashes(payload);
     const details = {};
@@ -5518,7 +5551,7 @@ var Account = class extends Provider {
     const declareContractTransaction = await this.buildDeclarePayload(declareContractPayload, {
       ...details,
       walletAddress: this.address,
-      cairoVersion: transactionsDetail.cairoVersion ?? "0"
+      cairoVersion: this.cairoVersion
     });
     return this.declareContract(declareContractTransaction, details);
   }
@@ -5554,10 +5587,7 @@ var Account = class extends Provider {
     });
     const calls = params.map((it) => it.call);
     const addresses = params.map((it) => it.address);
-    const invokeResponse = await this.execute(calls, void 0, {
-      ...details,
-      cairoVersion: "0"
-    });
+    const invokeResponse = await this.execute(calls, void 0, details);
     return {
       ...invokeResponse,
       contract_address: addresses
@@ -5572,15 +5602,18 @@ var Account = class extends Provider {
   }
   async declareAndDeploy(payload, details) {
     const { constructorCalldata, salt, unique } = payload;
-    const { transaction_hash, class_hash } = await this.declare(payload, details);
-    const declare = await this.waitForTransaction(transaction_hash, {
-      successStates: ["ACCEPTED_ON_L2" /* ACCEPTED_ON_L2 */]
-    });
+    let declare = await this.declareIfNot(payload, details);
+    if (declare.transaction_hash !== "") {
+      const tx = await this.waitForTransaction(declare.transaction_hash, {
+        successStates: ["ACCEPTED_ON_L2" /* ACCEPTED_ON_L2 */]
+      });
+      declare = { ...declare, ...tx };
+    }
     const deploy = await this.deployContract(
-      { classHash: class_hash, salt, unique, constructorCalldata },
+      { classHash: declare.class_hash, salt, unique, constructorCalldata },
       details
     );
-    return { declare: { ...declare, class_hash }, deploy };
+    return { declare: { ...declare }, deploy };
   }
   async deployAccount({
     classHash,
@@ -5596,13 +5629,18 @@ var Account = class extends Provider {
     const maxFee = transactionsDetail.maxFee ?? await this.getSuggestedMaxFee(
       {
         type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
-        payload: { classHash, constructorCalldata, addressSalt, contractAddress }
+        payload: {
+          classHash,
+          constructorCalldata: compiledCalldata,
+          addressSalt,
+          contractAddress
+        }
       },
       transactionsDetail
     );
     const signature = await this.signer.signDeployAccountTransaction({
       classHash,
-      constructorCalldata,
+      constructorCalldata: compiledCalldata,
       contractAddress,
       addressSalt,
       chainId,
@@ -5700,12 +5738,12 @@ var Account = class extends Provider {
       version,
       nonce,
       addressSalt,
-      constructorCalldata
+      constructorCalldata: compiledCalldata
     });
     return {
       classHash,
       addressSalt,
-      constructorCalldata,
+      constructorCalldata: compiledCalldata,
       signature
     };
   }
@@ -5732,7 +5770,7 @@ var Account = class extends Provider {
     });
     return calls;
   }
-  async simulateTransaction(calls, { nonce: providedNonce, blockIdentifier, skipValidate, cairoVersion } = {}) {
+  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);
@@ -5743,7 +5781,7 @@ var Account = class extends Provider {
       maxFee: ZERO,
       version,
       chainId,
-      cairoVersion: cairoVersion ?? "0"
+      cairoVersion: this.cairoVersion
     };
     const invocation = await this.buildInvocation(transactions, signerDetails);
     const response = await super.getSimulateTransaction(