starknet 8.5.5 → 8.6.0

package/dist/index.js

@@ -128,6 +128,7 @@ __export(index_exports, {
   addAddressPadding: () => addAddressPadding,
   byteArray: () => byteArray_exports,
   cairo: () => cairo_exports,
+  compareVersions: () => compareVersions,
   config: () => config,
   constants: () => constants_exports,
   contractClassResponseToLegacyCompiledContract: () => contractClassResponseToLegacyCompiledContract,
@@ -489,7 +490,8 @@ var DEFAULT_GLOBAL_CONFIG = {
   defaultTipType: "recommendedTip",
   fetch: void 0,
   websocket: void 0,
-  buffer: void 0
+  buffer: void 0,
+  blake: void 0
 };
 var RPC_DEFAULT_NODES = {
   SN_MAIN: [`https://starknet-mainnet.public.blastapi.io/rpc/`],
@@ -4786,12 +4788,16 @@ var CallData = class _CallData {
 // src/utils/hash/index.ts
 var hash_exports = {};
 __export(hash_exports, {
+  COMPILED_CLASS_VERSION: () => COMPILED_CLASS_VERSION,
+  blake2sHashMany: () => blake2sHashMany,
   calculateContractAddressFromHash: () => calculateContractAddressFromHash,
   calculateDeclareTransactionHash: () => calculateDeclareTransactionHash3,
   calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash3,
   calculateInvokeTransactionHash: () => calculateInvokeTransactionHash2,
   calculateL2MessageTxHash: () => calculateL2MessageTxHash,
   computeCompiledClassHash: () => computeCompiledClassHash,
+  computeCompiledClassHashBlake: () => computeCompiledClassHashBlake,
+  computeCompiledClassHashPoseidon: () => computeCompiledClassHashPoseidon,
   computeContractClassHash: () => computeContractClassHash,
   computeHashOnElements: () => computeHashOnElements2,
   computeHintedClassHash: () => computeHintedClassHash,
@@ -4801,13 +4807,17 @@ __export(hash_exports, {
   computePoseidonHash: () => computePoseidonHash,
   computePoseidonHashOnElements: () => computePoseidonHashOnElements,
   computeSierraContractClassHash: () => computeSierraContractClassHash,
+  encodeBuiltins: () => encodeBuiltins,
+  flattenEntryPointData: () => flattenEntryPointData,
   formatSpaces: () => formatSpaces,
   getL1MessageHash: () => getL1MessageHash,
   getL2MessageHash: () => getL2MessageHash,
   getSelector: () => getSelector,
   getSelectorFromName: () => getSelectorFromName,
   hashByteCodeSegments: () => hashByteCodeSegments,
+  hashByteCodeSegmentsBlake: () => hashByteCodeSegmentsBlake,
   keccakBn: () => keccakBn,
+  nullSkipReplacer: () => nullSkipReplacer,
   poseidon: () => poseidon,
   solidityUint256PackedKeccak256: () => solidityUint256PackedKeccak256,
   starknetKeccak: () => starknetKeccak
@@ -5072,21 +5082,51 @@ function calculateDeployAccountTransactionHash3(args) {
   throw new Error("Invalid Tx version for hash calculation");
 }
 
-// src/utils/hash/classHash.ts
-var import_starknet3 = require("@scure/starknet");
+// src/utils/hash/classHash/util.ts
+var COMPILED_CLASS_VERSION = "COMPILED_CLASS_V1";
+function formatSpaces(json2) {
+  let insideQuotes = false;
+  const newString = [];
+  for (const char of json2) {
+    if (char === '"' && (newString.length > 0 && newString.slice(-1)[0] === "\\") === false) {
+      insideQuotes = !insideQuotes;
+    }
+    if (insideQuotes) {
+      newString.push(char);
+    } else {
+      newString.push(char === ":" ? ": " : char === "," ? ", " : char);
+    }
+  }
+  return newString.join("");
+}
+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 encodeBuiltins(builtins) {
+  return builtins.map((it) => BigInt(encodeShortString(it)));
+}
+function flattenEntryPointData(data, encodedBuiltinsArray) {
+  return data.flatMap((it, index) => [
+    BigInt(it.selector),
+    BigInt(it.offset),
+    ...encodedBuiltinsArray[index]
+  ]);
+}
+
+// src/utils/hash/classHash/pedersen.ts
 function computePedersenHash(a, b) {
   return starkCurve.pedersen(BigInt(a), BigInt(b));
 }
-function computePoseidonHash(a, b) {
-  return toHex(starkCurve.poseidonHash(BigInt(a), BigInt(b)));
-}
 function computeHashOnElements2(data) {
   return [...data, data.length].reduce((x, y) => starkCurve.pedersen(BigInt(x), BigInt(y)), 0).toString();
 }
 var computePedersenHashOnElements = computeHashOnElements2;
-function computePoseidonHashOnElements(data) {
-  return toHex((0, import_starknet3.poseidonHashMany)(data.map((x) => BigInt(x))));
-}
 function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
   const compiledCalldata = CallData.compile(constructorCalldata);
   const constructorCalldataHash = computeHashOnElements2(compiledCalldata);
@@ -5100,30 +5140,6 @@ function calculateContractAddressFromHash(salt, classHash, constructorCalldata,
   ]);
   return toHex(BigInt(hash) % ADDR_BOUND);
 }
-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;
-  const newString = [];
-  for (const char of json2) {
-    if (char === '"' && (newString.length > 0 && newString.slice(-1)[0] === "\\") === false) {
-      insideQuotes = !insideQuotes;
-    }
-    if (insideQuotes) {
-      newString.push(char);
-    } else {
-      newString.push(char === ":" ? ": " : char === "," ? ", " : char);
-    }
-  }
-  return newString.join("");
-}
 function computeHintedClassHash(compiledContract) {
   const { abi, program } = compiledContract;
   const contractClass = { abi, program };
@@ -5157,12 +5173,17 @@ function computeLegacyContractClassHash(contract) {
     dataHash
   ]);
 }
+
+// src/utils/hash/classHash/poseidon.ts
+var import_starknet3 = require("@scure/starknet");
+function computePoseidonHash(a, b) {
+  return toHex(starkCurve.poseidonHash(BigInt(a), BigInt(b)));
+}
+function computePoseidonHashOnElements(data) {
+  return toHex((0, import_starknet3.poseidonHashMany)(data.map((x) => BigInt(x))));
+}
 function hashBuiltins(builtins) {
-  return (0, import_starknet3.poseidonHashMany)(
-    builtins.flatMap((it) => {
-      return BigInt(encodeShortString(it));
-    })
-  );
+  return (0, import_starknet3.poseidonHashMany)(encodeBuiltins(builtins));
 }
 function hashEntryPoint(data) {
   const base = data.flatMap((it) => {
@@ -5180,8 +5201,7 @@ function hashByteCodeSegments(casm) {
   });
   return 1n + (0, import_starknet3.poseidonHashMany)(hashLeaves);
 }
-function computeCompiledClassHash(casm) {
-  const COMPILED_CLASS_VERSION = "COMPILED_CLASS_V1";
+function computeCompiledClassHashPoseidon(casm) {
   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);
@@ -5226,6 +5246,161 @@ function computeSierraContractClassHash(sierra) {
     ])
   );
 }
+
+// src/utils/connect/blake.ts
+var import_blake2s = require("@noble/hashes/blake2s");
+function blakeHash(uint8Array) {
+  return config.get("blake")?.(uint8Array) || (0, import_blake2s.blake2s)(uint8Array, { dkLen: 32 });
+}
+
+// src/utils/hash/classHash/blake.ts
+function blake2sHashMany(data) {
+  const SMALL_THRESHOLD = 0x8000000000000000n;
+  const BIG_MARKER = 2147483648;
+  const u32Words = [];
+  const buf = new ArrayBuffer(32);
+  const feltView = new DataView(buf);
+  for (const felt2 of data) {
+    const u64_0 = felt2 & 0xffffffffffffffffn;
+    const u64_1 = (felt2 & 0xffffffffffffffff0000000000000000n) >> 64n;
+    const u64_2 = (felt2 & 0xffffffffffffffff00000000000000000000000000000000n) >> 128n;
+    const u64_3 = (felt2 & 0xffffffffffffffff000000000000000000000000000000000000000000000000n) >> 192n;
+    feltView.setBigUint64(0, u64_3, false);
+    feltView.setBigUint64(8, u64_2, false);
+    feltView.setBigUint64(16, u64_1, false);
+    feltView.setBigUint64(24, u64_0, false);
+    if (felt2 < SMALL_THRESHOLD) {
+      const hi0 = feltView.getUint32(24, false);
+      const lo0 = feltView.getUint32(28, false);
+      u32Words.push(hi0, lo0);
+    } else {
+      const word0 = feltView.getUint32(0, false) | BIG_MARKER;
+      const word1 = feltView.getUint32(4, false);
+      const word2 = feltView.getUint32(8, false);
+      const word3 = feltView.getUint32(12, false);
+      const word4 = feltView.getUint32(16, false);
+      const word5 = feltView.getUint32(20, false);
+      const word6 = feltView.getUint32(24, false);
+      const word7 = feltView.getUint32(28, false);
+      u32Words.push(word0, word1, word2, word3, word4, word5, word6, word7);
+    }
+  }
+  const bytes = new ArrayBuffer(u32Words.length * 4);
+  const bytesView = new DataView(bytes);
+  for (let i = 0; i < u32Words.length; i++) {
+    bytesView.setUint32(i * 4, u32Words[i], true);
+  }
+  const hash = blakeHash(new Uint8Array(bytes));
+  let hashBigInt = 0n;
+  for (let i = 0; i < 32; i++) {
+    hashBigInt |= BigInt(hash[i]) << BigInt(i * 8);
+  }
+  return hashBigInt % PRIME;
+}
+function hashBuiltinsBlake(builtins) {
+  return blake2sHashMany(encodeBuiltins(builtins));
+}
+function hashEntryPointBlake(data) {
+  const base = data.flatMap((it) => {
+    return [BigInt(it.selector), BigInt(it.offset), hashBuiltinsBlake(it.builtins)];
+  });
+  return blake2sHashMany(base);
+}
+function bytecodeHashNodeBlake(iter, node) {
+  if (typeof node === "number") {
+    const data = [];
+    for (let i = 0; i < node; i++) {
+      const next = iter.next();
+      if (next.done) throw new Error("Bytecode length mismatch");
+      data.push(next.value);
+    }
+    return [node, blake2sHashMany(data)];
+  }
+  const innerNodes = node.map((child) => bytecodeHashNodeBlake(iter, child));
+  const flatData = innerNodes.flatMap(([len, hash2]) => [BigInt(len), hash2]);
+  const hash = blake2sHashMany(flatData) + 1n;
+  const totalLen = innerNodes.reduce((sum, [len]) => sum + len, 0);
+  return [totalLen, hash];
+}
+function hashByteCodeSegmentsBlake(casm) {
+  const byteCode = casm.bytecode.map((n) => BigInt(n));
+  const bytecodeSegmentLengths = casm.bytecode_segment_lengths;
+  if (!bytecodeSegmentLengths) {
+    return blake2sHashMany(byteCode);
+  }
+  const iter = byteCode[Symbol.iterator]();
+  const [len, hash] = bytecodeHashNodeBlake(iter, bytecodeSegmentLengths);
+  if (len !== byteCode.length) {
+    throw new Error(`Bytecode length mismatch: expected ${byteCode.length}, got ${len}`);
+  }
+  return hash;
+}
+function computeCompiledClassHashBlake(casm) {
+  const compiledClassVersion = BigInt(encodeShortString(COMPILED_CLASS_VERSION));
+  const externalEntryPointsHash = hashEntryPointBlake(casm.entry_points_by_type.EXTERNAL);
+  const l1Handlers = hashEntryPointBlake(casm.entry_points_by_type.L1_HANDLER);
+  const constructor = hashEntryPointBlake(casm.entry_points_by_type.CONSTRUCTOR);
+  const bytecode = hashByteCodeSegmentsBlake(casm);
+  return toHex(
+    blake2sHashMany([
+      compiledClassVersion,
+      externalEntryPointsHash,
+      l1Handlers,
+      constructor,
+      bytecode
+    ])
+  );
+}
+
+// src/utils/resolve.ts
+function isV3Tx(details) {
+  const version = details.version ? toHex(details.version) : ETransactionVersion2.V3;
+  return version === ETransactionVersion2.V3 || version === ETransactionVersion2.F3;
+}
+function isVersion(expected, provided) {
+  const expectedParts = expected.split(".");
+  const providedParts = provided.split(".");
+  return expectedParts.every((part, index) => part === "*" || part === providedParts[index]);
+}
+function isSupportedSpecVersion(version, options = { allowAnyPatchVersion: false }) {
+  return Object.values(_SupportedRpcVersion).some(
+    (v) => isVersion(options.allowAnyPatchVersion ? toAnyPatchVersion(v) : v, version)
+  );
+}
+function toAnyPatchVersion(version) {
+  const parts = version.split(".");
+  if (parts.length < 3) {
+    return version;
+  }
+  return `${parts[0]}.${parts[1]}.*`;
+}
+function toApiVersion(version) {
+  const [major, minor] = version.replace(/^v/, "").split(".");
+  return `v${major}_${minor}`;
+}
+function compareVersions(a, b) {
+  const aParts = a.split(".").map(Number);
+  const bParts = b.split(".").map(Number);
+  const maxLen = Math.max(aParts.length, bParts.length);
+  for (let i = 0; i < maxLen; i += 1) {
+    const aNum = aParts[i] || 0;
+    const bNum = bParts[i] || 0;
+    if (aNum > bNum) return 1;
+    if (aNum < bNum) return -1;
+  }
+  return 0;
+}
+function isPendingBlock(response) {
+  return response.status === "PENDING";
+}
+function isPendingTransaction(response) {
+  return !("block_hash" in response);
+}
+function isPendingStateUpdate(response) {
+  return !("block_hash" in response);
+}
+
+// src/utils/hash/classHash/index.ts
 function computeContractClassHash(contract) {
   const compiledContract = isString(contract) ? parse2(contract) : contract;
   if ("sierra_program" in compiledContract) {
@@ -5233,6 +5408,12 @@ function computeContractClassHash(contract) {
   }
   return computeLegacyContractClassHash(compiledContract);
 }
+function computeCompiledClassHash(casm, specVersion) {
+  if (specVersion && compareVersions(specVersion, "0.10.0") >= 0) {
+    return computeCompiledClassHashBlake(casm);
+  }
+  return computeCompiledClassHashPoseidon(casm);
+}
 
 // src/utils/stark/index.ts
 var stark_exports = {};
@@ -5438,11 +5619,11 @@ function isSierra(contract) {
   const compiledContract = isString(contract) ? parse2(contract) : contract;
   return "sierra_program" in compiledContract;
 }
-function extractContractHashes(payload) {
+function extractContractHashes(payload, specVersion) {
   const response = { ...payload };
   if (isSierra(payload.contract)) {
     if (!payload.compiledClassHash && payload.casm) {
-      response.compiledClassHash = computeCompiledClassHash(payload.casm);
+      response.compiledClassHash = computeCompiledClassHash(payload.casm, specVersion);
     }
     if (!response.compiledClassHash)
       throw new Error(
@@ -5499,44 +5680,6 @@ __export(provider_exports, {
   validBlockTags: () => validBlockTags,
   wait: () => wait
 });
-
-// src/utils/resolve.ts
-function isV3Tx(details) {
-  const version = details.version ? toHex(details.version) : ETransactionVersion2.V3;
-  return version === ETransactionVersion2.V3 || version === ETransactionVersion2.F3;
-}
-function isVersion(expected, provided) {
-  const expectedParts = expected.split(".");
-  const providedParts = provided.split(".");
-  return expectedParts.every((part, index) => part === "*" || part === providedParts[index]);
-}
-function isSupportedSpecVersion(version, options = { allowAnyPatchVersion: false }) {
-  return Object.values(_SupportedRpcVersion).some(
-    (v) => isVersion(options.allowAnyPatchVersion ? toAnyPatchVersion(v) : v, version)
-  );
-}
-function toAnyPatchVersion(version) {
-  const parts = version.split(".");
-  if (parts.length < 3) {
-    return version;
-  }
-  return `${parts[0]}.${parts[1]}.*`;
-}
-function toApiVersion(version) {
-  const [major, minor] = version.replace(/^v/, "").split(".");
-  return `v${major}_${minor}`;
-}
-function isPendingBlock(response) {
-  return response.status === "PENDING";
-}
-function isPendingTransaction(response) {
-  return !("block_hash" in response);
-}
-function isPendingStateUpdate(response) {
-  return !("block_hash" in response);
-}
-
-// src/utils/provider.ts
 function wait(delay) {
   return new Promise((res) => {
     setTimeout(res, delay);
@@ -8710,7 +8853,10 @@ var RpcProvider = class {
   async isClassDeclared(contractClassIdentifier, blockIdentifier) {
     let classHash;
     if (!contractClassIdentifier.classHash && "contract" in contractClassIdentifier) {
-      const hashes = extractContractHashes(contractClassIdentifier);
+      const hashes = extractContractHashes(
+        contractClassIdentifier,
+        await this.channel.setUpSpecVersion()
+      );
       classHash = hashes.classHash;
     } else if (contractClassIdentifier.classHash) {
       classHash = contractClassIdentifier.classHash;
@@ -11081,7 +11227,10 @@ var Account = class extends RpcProvider2 {
       "Declare fee estimation is not supported for Cairo0 contracts"
     );
     const invocations = [
-      { type: api_exports.ETransactionType.DECLARE, payload: extractContractHashes(payload) }
+      {
+        type: api_exports.ETransactionType.DECLARE,
+        payload: extractContractHashes(payload, await this.channel.setUpSpecVersion())
+      }
     ];
     const estimateBulk = await this.estimateFeeBulk(invocations, details);
     return estimateBulk[0];
@@ -11244,7 +11393,10 @@ var Account = class extends RpcProvider2 {
    * @param transactionsDetail (optional)
    */
   async declareIfNot(payload, transactionsDetail = {}) {
-    const declareContractPayload = extractContractHashes(payload);
+    const declareContractPayload = extractContractHashes(
+      payload,
+      await this.channel.setUpSpecVersion()
+    );
     try {
       await this.getClassByHash(declareContractPayload.classHash);
     } catch (error) {
@@ -11257,7 +11409,10 @@ var Account = class extends RpcProvider2 {
   }
   async declare(payload, details = {}) {
     assert(isSierra(payload.contract), SYSTEM_MESSAGES.declareNonSierra);
-    const declareContractPayload = extractContractHashes(payload);
+    const declareContractPayload = extractContractHashes(
+      payload,
+      await this.channel.setUpSpecVersion()
+    );
     const detailsWithTip = await this.resolveDetailsWithTip(details);
     const { resourceBounds: providedResourceBounds } = details;
     let resourceBounds = providedResourceBounds;
@@ -11564,7 +11719,10 @@ var Account = class extends RpcProvider2 {
     };
   }
   async buildDeclarePayload(payload, details) {
-    const { classHash, contract, compiledClassHash } = extractContractHashes(payload);
+    const { classHash, contract, compiledClassHash } = extractContractHashes(
+      payload,
+      await this.channel.setUpSpecVersion()
+    );
     const compressedCompiledContract = parseContract(contract);
     assert(
       !isUndefined(compiledClassHash) && (details.version === ETransactionVersion3.F3 || details.version === ETransactionVersion3.V3),
@@ -11910,8 +12068,11 @@ var WalletAccount = class _WalletAccount extends Account {
     };
     return addInvokeTransaction(this.walletProvider, params);
   }
-  declare(payload) {
-    const declareContractPayload = extractContractHashes(payload);
+  async declare(payload) {
+    const declareContractPayload = extractContractHashes(
+      payload,
+      await this.channel.setUpSpecVersion()
+    );
     const pContract = payload.contract;
     const cairo1Contract = {
       ...pContract,
@@ -12623,6 +12784,7 @@ function units(amount, simbol = "fri") {
   addAddressPadding,
   byteArray,
   cairo,
+  compareVersions,
   config,
   constants,
   contractClassResponseToLegacyCompiledContract,