starknet 5.1.1 → 5.2.0

package/dist/index.js

@@ -110,8 +110,11 @@ __export(hash_exports, {
   calculateDeployTransactionHash: () => calculateDeployTransactionHash,
   calculateTransactionHash: () => calculateTransactionHash,
   calculateTransactionHashCommon: () => calculateTransactionHashCommon,
+  computeCompiledClassHash: () => computeCompiledClassHash,
   computeContractClassHash: () => computeContractClassHash,
   computeHashOnElements: () => computeHashOnElements,
+  computeLegacyContractClassHash: () => computeLegacyContractClassHash,
+  computeSieraContractClassHash: () => computeSieraContractClassHash,
   default: () => computeHintedClassHash,
   feeTransactionVersion: () => feeTransactionVersion,
   getSelector: () => getSelector,
@@ -123,6 +126,8 @@ __export(hash_exports, {
 });
 var import_keccak = require("ethereum-cryptography/keccak.js");
 var import_utils = require("ethereum-cryptography/utils.js");
+var import_json_keys_sort = require("json-keys-sort");
+var import_micro_starknet = require("micro-starknet");
 
 // src/constants.ts
 var constants_exports = {};
@@ -2477,7 +2482,7 @@ __export(ec_exports, {
   starkCurve: () => starkCurve,
   weierstrass: () => weierstrass
 });
-var starkCurve = __toESM(require("@noble/curves/stark"));
+var starkCurve = __toESM(require("micro-starknet"));
 var weierstrass = __toESM(require("@noble/curves/abstract/weierstrass"));
 
 // src/utils/json.ts
@@ -2615,32 +2620,28 @@ function nullSkipReplacer(key, value) {
   }
   return value === null ? void 0 : value;
 }
+function formatSpaces(json2) {
+  let insideQuotes = false;
+  let newString = "";
+  for (const char of json2) {
+    if (char === '"' && newString.endsWith("\\") === false) {
+      insideQuotes = !insideQuotes;
+    }
+    if (insideQuotes) {
+      newString += char;
+    } else {
+      newString += char === ":" ? ": " : char === "," ? ", " : char;
+    }
+  }
+  return newString;
+}
 function computeHintedClassHash(compiledContract) {
   const { abi, program } = compiledContract;
   const contractClass = { abi, program };
-  const serialisedJson = stringify(contractClass, nullSkipReplacer).split("").reduce(
-    ([insideQuotes, newString], char) => {
-      if (char === '"' && newString[newString.length - 1] !== "\\") {
-        insideQuotes = !insideQuotes;
-      }
-      if (insideQuotes) {
-        newString += char;
-        return [insideQuotes, newString];
-      }
-      if (char === ":" && !insideQuotes) {
-        newString += ": ";
-      } else if (char === "," && !insideQuotes) {
-        newString += ", ";
-      } else {
-        newString += char;
-      }
-      return [insideQuotes, newString];
-    },
-    [false, ""]
-  )[1];
-  return addHexPrefix(starkCurve.keccak(utf8ToArray(serialisedJson)).toString(16));
+  const serializedJson = formatSpaces(stringify(contractClass, nullSkipReplacer));
+  return addHexPrefix(starkCurve.keccak(utf8ToArray(serializedJson)).toString(16));
 }
-function computeContractClassHash(contract) {
+function computeLegacyContractClassHash(contract) {
   const compiledContract = typeof contract === "string" ? parse(contract) : contract;
   const apiVersion = toHex(API_VERSION);
   const externalEntryPointsHash = computeHashOnElements(
@@ -2667,6 +2668,97 @@ function computeContractClassHash(contract) {
     dataHash
   ]);
 }
+function hashBuiltins(builtins) {
+  return (0, import_micro_starknet.poseidonHashMany)(
+    builtins.flatMap((it) => {
+      return BigInt(encodeShortString(it));
+    })
+  );
+}
+function hashEntryPoint(data) {
+  const base = data.flatMap((it) => {
+    return [BigInt(it.selector), BigInt(it.offset), hashBuiltins(it.builtins)];
+  });
+  return (0, import_micro_starknet.poseidonHashMany)(base);
+}
+function 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 = (0, import_json_keys_sort.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 = (0, import_micro_starknet.poseidonHashMany)(casm.bytecode.map((it) => BigInt(it)));
+  return toHex(
+    (0, import_micro_starknet.poseidonHashMany)([
+      compiledClassVersion,
+      externalEntryPointsHash,
+      l1Handlers,
+      constructor,
+      hintedCompiledClassHash,
+      bytecode
+    ])
+  );
+}
+function hashEntryPointSiera(data) {
+  const base = data.flatMap((it) => {
+    return [BigInt(it.selector), BigInt(it.function_idx)];
+  });
+  return (0, import_micro_starknet.poseidonHashMany)(base);
+}
+function hashAbi(siera) {
+  const indentString = stringify(siera.abi, null, 2);
+  return BigInt(addHexPrefix(starkCurve.keccak(utf8ToArray(indentString)).toString(16)));
+}
+function computeSieraContractClassHash(siera) {
+  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 = (0, import_micro_starknet.poseidonHashMany)(siera.sierra_program.map((it) => BigInt(it)));
+  return toHex(
+    (0, import_micro_starknet.poseidonHashMany)([
+      compiledClassVersion,
+      externalEntryPointsHash,
+      l1Handlers,
+      constructor,
+      abiHash,
+      sieraProgram
+    ])
+  );
+}
+function computeContractClassHash(contract) {
+  const compiledContract = typeof contract === "string" ? parse(contract) : contract;
+  if ("sierra_program" in compiledContract) {
+    return computeSieraContractClassHash(compiledContract);
+  }
+  return computeLegacyContractClassHash(compiledContract);
+}
 
 // src/utils/stark.ts
 var stark_exports = {};
@@ -2681,7 +2773,7 @@ __export(stark_exports, {
   signatureToDecimalArray: () => signatureToDecimalArray,
   signatureToHexArray: () => signatureToHexArray
 });
-var import_stark = require("@noble/curves/stark");
+var import_micro_starknet2 = require("micro-starknet");
 var import_pako = require("pako");
 function compressProgram(jsonProgram) {
   const stringified = typeof jsonProgram === "string" ? jsonProgram : stringify(jsonProgram);
@@ -2689,8 +2781,8 @@ function compressProgram(jsonProgram) {
   return btoaUniversal(compressedProgram);
 }
 function randomAddress() {
-  const randomKeyPair = import_stark.utils.randomPrivateKey();
-  return (0, import_stark.getStarkKey)(randomKeyPair);
+  const randomKeyPair = import_micro_starknet2.utils.randomPrivateKey();
+  return (0, import_micro_starknet2.getStarkKey)(randomKeyPair);
 }
 function makeAddress(input) {
   return addHexPrefix(input).toLowerCase();
@@ -2715,7 +2807,7 @@ function parseSignature(sig) {
   if (!sig)
     return void 0;
   const [r, s] = sig;
-  return new import_stark.Signature(toBigInt(r), toBigInt(s));
+  return new import_micro_starknet2.Signature(toBigInt(r), toBigInt(s));
 }
 function compileCalldata(args) {
   const compiledData = Object.values(args).flatMap((value) => {
@@ -5432,7 +5524,7 @@ var AccountInterface = class extends ProviderInterface {
 };
 
 // src/utils/address.ts
-var import_bytes = require("@ethersproject/bytes");
+var import_utils5 = require("@noble/curves/abstract/utils");
 function addAddressPadding(address) {
   return addHexPrefix(removeHexPrefix(toHex(address)).padStart(64, "0"));
 }
@@ -5446,7 +5538,8 @@ function validateAndParseAddress(address) {
 }
 function getChecksumAddress(address) {
   const chars = removeHexPrefix(validateAndParseAddress(address)).toLowerCase().split("");
-  const hashed = (0, import_bytes.arrayify)(keccakBn(address), { hexPad: "left" });
+  const hex = removeHexPrefix(keccakBn(address));
+  const hashed = (0, import_utils5.hexToBytes)(hex.padStart(64, "0"));
   for (let i = 0; i < chars.length; i += 2) {
     if (hashed[i >> 1] >> 4 >= 8) {
       chars[i] = chars[i].toUpperCase();