starknet 5.1.0 → 5.2.0

package/dist/index.mjs

@@ -48,8 +48,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,
@@ -61,6 +64,8 @@ __export(hash_exports, {
 });
 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";
 
 // src/constants.ts
 var constants_exports = {};
@@ -2415,7 +2420,7 @@ __export(ec_exports, {
   starkCurve: () => starkCurve,
   weierstrass: () => weierstrass
 });
-import * as starkCurve from "@noble/curves/stark";
+import * as starkCurve from "micro-starknet";
 import * as weierstrass from "@noble/curves/abstract/weierstrass";
 
 // src/utils/json.ts
@@ -2553,32 +2558,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(
@@ -2605,6 +2606,97 @@ function computeContractClassHash(contract) {
     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 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([
+      compiledClassVersion,
+      externalEntryPointsHash,
+      l1Handlers,
+      constructor,
+      hintedCompiledClassHash,
+      bytecode
+    ])
+  );
+}
+function hashEntryPointSiera(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);
+  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 = poseidonHashMany(siera.sierra_program.map((it) => BigInt(it)));
+  return toHex(
+    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 = {};
@@ -2619,7 +2711,7 @@ __export(stark_exports, {
   signatureToDecimalArray: () => signatureToDecimalArray,
   signatureToHexArray: () => signatureToHexArray
 });
-import { Signature, getStarkKey, utils } from "@noble/curves/stark";
+import { Signature, getStarkKey, utils } from "micro-starknet";
 import { gzip } from "pako";
 function compressProgram(jsonProgram) {
   const stringified = typeof jsonProgram === "string" ? jsonProgram : stringify(jsonProgram);
@@ -5370,7 +5462,7 @@ var AccountInterface = class extends ProviderInterface {
 };
 
 // src/utils/address.ts
-import { arrayify } from "@ethersproject/bytes";
+import { hexToBytes as hexToBytes2 } from "@noble/curves/abstract/utils";
 function addAddressPadding(address) {
   return addHexPrefix(removeHexPrefix(toHex(address)).padStart(64, "0"));
 }
@@ -5384,7 +5476,8 @@ function validateAndParseAddress(address) {
 }
 function getChecksumAddress(address) {
   const chars = removeHexPrefix(validateAndParseAddress(address)).toLowerCase().split("");
-  const hashed = arrayify(keccakBn(address), { hexPad: "left" });
+  const hex = removeHexPrefix(keccakBn(address));
+  const hashed = hexToBytes2(hex.padStart(64, "0"));
   for (let i = 0; i < chars.length; i += 2) {
     if (hashed[i >> 1] >> 4 >= 8) {
       chars[i] = chars[i].toUpperCase();