starknet 8.5.5 → 8.6.0

package/dist/index.global.js

@@ -118,6 +118,7 @@ var starknet = (() => {
     addAddressPadding: () => addAddressPadding,
     byteArray: () => byteArray_exports,
     cairo: () => cairo_exports,
+    compareVersions: () => compareVersions,
     config: () => config,
     constants: () => constants_exports,
     contractClassResponseToLegacyCompiledContract: () => contractClassResponseToLegacyCompiledContract,
@@ -1174,7 +1175,8 @@ var starknet = (() => {
     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/`],
@@ -2512,6 +2514,7 @@ ${indent}}` : "}";
   var rotr = (word, shift) => word << 32 - shift | word >>> shift;
   var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
   var byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+  var byteSwapIfBE = isLE ? (n) => n : (n) => byteSwap(n);
   function byteSwap32(arr) {
     for (let i = 0; i < arr.length; i++) {
       arr[i] = byteSwap(arr[i]);
@@ -2542,6 +2545,14 @@ ${indent}}` : "}";
     hashC.create = () => hashCons();
     return hashC;
   }
+  function wrapConstructorWithOpts(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+  }
   function wrapXOFConstructorWithOpts(hashCons) {
     const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
     const tmp = hashCons({});
@@ -8912,12 +8923,16 @@ ${indent}}` : "}";
   // 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: () => computeHashOnElements3,
     computeHintedClassHash: () => computeHintedClassHash,
@@ -8927,13 +8942,17 @@ ${indent}}` : "}";
     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_exports,
     solidityUint256PackedKeccak256: () => solidityUint256PackedKeccak256,
     starknetKeccak: () => starknetKeccak
@@ -9194,20 +9213,51 @@ ${indent}}` : "}";
     throw new Error("Invalid Tx version for hash calculation");
   }
 
-  // src/utils/hash/classHash.ts
+  // src/utils/hash/classHash/util.ts
+  var COMPILED_CLASS_VERSION = "COMPILED_CLASS_V1";
+  function formatSpaces(json) {
+    let insideQuotes = false;
+    const newString = [];
+    for (const char of json) {
+      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 esm_exports4.pedersen(BigInt(a), BigInt(b));
   }
-  function computePoseidonHash(a, b) {
-    return toHex(esm_exports4.poseidonHash(BigInt(a), BigInt(b)));
-  }
   function computeHashOnElements3(data) {
     return [...data, data.length].reduce((x, y) => esm_exports4.pedersen(BigInt(x), BigInt(y)), 0).toString();
   }
   var computePedersenHashOnElements = computeHashOnElements3;
-  function computePoseidonHashOnElements(data) {
-    return toHex(poseidonHashMany(data.map((x) => BigInt(x))));
-  }
   function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
     const compiledCalldata = CallData.compile(constructorCalldata);
     const constructorCalldataHash = computeHashOnElements3(compiledCalldata);
@@ -9221,30 +9271,6 @@ ${indent}}` : "}";
     ]);
     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(json) {
-    let insideQuotes = false;
-    const newString = [];
-    for (const char of json) {
-      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 };
@@ -9278,12 +9304,16 @@ ${indent}}` : "}";
       dataHash
     ]);
   }
+
+  // src/utils/hash/classHash/poseidon.ts
+  function computePoseidonHash(a, b) {
+    return toHex(esm_exports4.poseidonHash(BigInt(a), BigInt(b)));
+  }
+  function computePoseidonHashOnElements(data) {
+    return toHex(poseidonHashMany(data.map((x) => BigInt(x))));
+  }
   function hashBuiltins(builtins) {
-    return poseidonHashMany(
-      builtins.flatMap((it) => {
-        return BigInt(encodeShortString(it));
-      })
-    );
+    return poseidonHashMany(encodeBuiltins(builtins));
   }
   function hashEntryPoint(data) {
     const base = data.flatMap((it) => {
@@ -9301,8 +9331,7 @@ ${indent}}` : "}";
     });
     return 1n + 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);
@@ -9347,6 +9376,561 @@ ${indent}}` : "}";
       ])
     );
   }
+
+  // node_modules/@noble/hashes/esm/_blake.js
+  var SIGMA = /* @__PURE__ */ new Uint8Array([
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    14,
+    10,
+    4,
+    8,
+    9,
+    15,
+    13,
+    6,
+    1,
+    12,
+    0,
+    2,
+    11,
+    7,
+    5,
+    3,
+    11,
+    8,
+    12,
+    0,
+    5,
+    2,
+    15,
+    13,
+    10,
+    14,
+    3,
+    6,
+    7,
+    1,
+    9,
+    4,
+    7,
+    9,
+    3,
+    1,
+    13,
+    12,
+    11,
+    14,
+    2,
+    6,
+    5,
+    10,
+    4,
+    0,
+    15,
+    8,
+    9,
+    0,
+    5,
+    7,
+    2,
+    4,
+    10,
+    15,
+    14,
+    1,
+    11,
+    12,
+    6,
+    8,
+    3,
+    13,
+    2,
+    12,
+    6,
+    10,
+    0,
+    11,
+    8,
+    3,
+    4,
+    13,
+    7,
+    5,
+    15,
+    14,
+    1,
+    9,
+    12,
+    5,
+    1,
+    15,
+    14,
+    13,
+    4,
+    10,
+    0,
+    7,
+    6,
+    3,
+    9,
+    2,
+    8,
+    11,
+    13,
+    11,
+    7,
+    14,
+    12,
+    1,
+    3,
+    9,
+    5,
+    0,
+    15,
+    4,
+    8,
+    6,
+    2,
+    10,
+    6,
+    15,
+    14,
+    9,
+    11,
+    3,
+    0,
+    8,
+    12,
+    2,
+    13,
+    7,
+    1,
+    4,
+    10,
+    5,
+    10,
+    2,
+    8,
+    4,
+    7,
+    6,
+    1,
+    5,
+    15,
+    11,
+    9,
+    14,
+    3,
+    12,
+    13,
+    0,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    14,
+    10,
+    4,
+    8,
+    9,
+    15,
+    13,
+    6,
+    1,
+    12,
+    0,
+    2,
+    11,
+    7,
+    5,
+    3
+  ]);
+  var BLAKE = class extends Hash {
+    constructor(blockLen, outputLen, opts = {}, keyLen, saltLen, persLen) {
+      super();
+      this.blockLen = blockLen;
+      this.outputLen = outputLen;
+      this.length = 0;
+      this.pos = 0;
+      this.finished = false;
+      this.destroyed = false;
+      anumber2(blockLen);
+      anumber2(outputLen);
+      anumber2(keyLen);
+      if (outputLen < 0 || outputLen > keyLen)
+        throw new Error("outputLen bigger than keyLen");
+      if (opts.key !== void 0 && (opts.key.length < 1 || opts.key.length > keyLen))
+        throw new Error("key length must be undefined or 1.." + keyLen);
+      if (opts.salt !== void 0 && opts.salt.length !== saltLen)
+        throw new Error("salt must be undefined or " + saltLen);
+      if (opts.personalization !== void 0 && opts.personalization.length !== persLen)
+        throw new Error("personalization must be undefined or " + persLen);
+      this.buffer = new Uint8Array(blockLen);
+      this.buffer32 = u32(this.buffer);
+    }
+    update(data) {
+      aexists(this);
+      const { blockLen, buffer, buffer32 } = this;
+      data = toBytes(data);
+      const len = data.length;
+      const offset = data.byteOffset;
+      const buf = data.buffer;
+      for (let pos = 0; pos < len; ) {
+        if (this.pos === blockLen) {
+          if (!isLE)
+            byteSwap32(buffer32);
+          this.compress(buffer32, 0, false);
+          if (!isLE)
+            byteSwap32(buffer32);
+          this.pos = 0;
+        }
+        const take = Math.min(blockLen - this.pos, len - pos);
+        const dataOffset = offset + pos;
+        if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+          const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+          if (!isLE)
+            byteSwap32(data32);
+          for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+            this.length += blockLen;
+            this.compress(data32, pos32, false);
+          }
+          if (!isLE)
+            byteSwap32(data32);
+          continue;
+        }
+        buffer.set(data.subarray(pos, pos + take), this.pos);
+        this.pos += take;
+        this.length += take;
+        pos += take;
+      }
+      return this;
+    }
+    digestInto(out) {
+      aexists(this);
+      aoutput(out, this);
+      const { pos, buffer32 } = this;
+      this.finished = true;
+      this.buffer.subarray(pos).fill(0);
+      if (!isLE)
+        byteSwap32(buffer32);
+      this.compress(buffer32, 0, true);
+      if (!isLE)
+        byteSwap32(buffer32);
+      const out32 = u32(out);
+      this.get().forEach((v, i) => out32[i] = byteSwapIfBE(v));
+    }
+    digest() {
+      const { buffer, outputLen } = this;
+      this.digestInto(buffer);
+      const res = buffer.slice(0, outputLen);
+      this.destroy();
+      return res;
+    }
+    _cloneInto(to) {
+      const { buffer, length, finished, destroyed, outputLen, pos } = this;
+      to || (to = new this.constructor({ dkLen: outputLen }));
+      to.set(...this.get());
+      to.length = length;
+      to.finished = finished;
+      to.destroyed = destroyed;
+      to.outputLen = outputLen;
+      to.buffer.set(buffer);
+      to.pos = pos;
+      return to;
+    }
+  };
+
+  // node_modules/@noble/hashes/esm/blake2s.js
+  var B2S_IV = /* @__PURE__ */ new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  function G1s(a, b, c, d, x) {
+    a = a + b + x | 0;
+    d = rotr(d ^ a, 16);
+    c = c + d | 0;
+    b = rotr(b ^ c, 12);
+    return { a, b, c, d };
+  }
+  function G2s(a, b, c, d, x) {
+    a = a + b + x | 0;
+    d = rotr(d ^ a, 8);
+    c = c + d | 0;
+    b = rotr(b ^ c, 7);
+    return { a, b, c, d };
+  }
+  function compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {
+    let j = 0;
+    for (let i = 0; i < rounds; i++) {
+      ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));
+      ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));
+      ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));
+      ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));
+      ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));
+      ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));
+      ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));
+      ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));
+      ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));
+      ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));
+      ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));
+      ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));
+      ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));
+      ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));
+      ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));
+      ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));
+    }
+    return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
+  }
+  var BLAKE2s = class extends BLAKE {
+    constructor(opts = {}) {
+      super(64, opts.dkLen === void 0 ? 32 : opts.dkLen, opts, 32, 8, 8);
+      this.v0 = B2S_IV[0] | 0;
+      this.v1 = B2S_IV[1] | 0;
+      this.v2 = B2S_IV[2] | 0;
+      this.v3 = B2S_IV[3] | 0;
+      this.v4 = B2S_IV[4] | 0;
+      this.v5 = B2S_IV[5] | 0;
+      this.v6 = B2S_IV[6] | 0;
+      this.v7 = B2S_IV[7] | 0;
+      const keyLength = opts.key ? opts.key.length : 0;
+      this.v0 ^= this.outputLen | keyLength << 8 | 1 << 16 | 1 << 24;
+      if (opts.salt) {
+        const salt = u32(toBytes(opts.salt));
+        this.v4 ^= byteSwapIfBE(salt[0]);
+        this.v5 ^= byteSwapIfBE(salt[1]);
+      }
+      if (opts.personalization) {
+        const pers = u32(toBytes(opts.personalization));
+        this.v6 ^= byteSwapIfBE(pers[0]);
+        this.v7 ^= byteSwapIfBE(pers[1]);
+      }
+      if (opts.key) {
+        const tmp = new Uint8Array(this.blockLen);
+        tmp.set(toBytes(opts.key));
+        this.update(tmp);
+      }
+    }
+    get() {
+      const { v0, v1, v2, v3, v4, v5, v6, v7 } = this;
+      return [v0, v1, v2, v3, v4, v5, v6, v7];
+    }
+    // prettier-ignore
+    set(v0, v1, v2, v3, v4, v5, v6, v7) {
+      this.v0 = v0 | 0;
+      this.v1 = v1 | 0;
+      this.v2 = v2 | 0;
+      this.v3 = v3 | 0;
+      this.v4 = v4 | 0;
+      this.v5 = v5 | 0;
+      this.v6 = v6 | 0;
+      this.v7 = v7 | 0;
+    }
+    compress(msg, offset, isLast) {
+      const { h, l } = fromBig(BigInt(this.length));
+      const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(SIGMA, offset, msg, 10, this.v0, this.v1, this.v2, this.v3, this.v4, this.v5, this.v6, this.v7, B2S_IV[0], B2S_IV[1], B2S_IV[2], B2S_IV[3], l ^ B2S_IV[4], h ^ B2S_IV[5], isLast ? ~B2S_IV[6] : B2S_IV[6], B2S_IV[7]);
+      this.v0 ^= v0 ^ v8;
+      this.v1 ^= v1 ^ v9;
+      this.v2 ^= v2 ^ v10;
+      this.v3 ^= v3 ^ v11;
+      this.v4 ^= v4 ^ v12;
+      this.v5 ^= v5 ^ v13;
+      this.v6 ^= v6 ^ v14;
+      this.v7 ^= v7 ^ v15;
+    }
+    destroy() {
+      this.destroyed = true;
+      this.buffer32.fill(0);
+      this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    }
+  };
+  var blake2s = /* @__PURE__ */ wrapConstructorWithOpts((opts) => new BLAKE2s(opts));
+
+  // src/utils/connect/blake.ts
+  function blakeHash(uint8Array) {
+    return config.get("blake")?.(uint8Array) || 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) : ETransactionVersion5.V3;
+    return version === ETransactionVersion5.V3 || version === ETransactionVersion5.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) {
@@ -9354,6 +9938,12 @@ ${indent}}` : "}";
     }
     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 = {};
@@ -13734,11 +14324,11 @@ ${indent}}` : "}";
     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(
@@ -14128,44 +14718,6 @@ ${indent}}` : "}";
     validBlockTags: () => validBlockTags,
     wait: () => wait
   });
-
-  // src/utils/resolve.ts
-  function isV3Tx(details) {
-    const version = details.version ? toHex(details.version) : ETransactionVersion5.V3;
-    return version === ETransactionVersion5.V3 || version === ETransactionVersion5.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);
@@ -17339,7 +17891,10 @@ ${indent}}` : "}";
     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;
@@ -19927,7 +20482,10 @@ ${indent}}` : "}";
         "Declare fee estimation is not supported for Cairo0 contracts"
       );
       const invocations = [
-        { type: ETransactionType2.DECLARE, payload: extractContractHashes(payload) }
+        {
+          type: ETransactionType2.DECLARE,
+          payload: extractContractHashes(payload, await this.channel.setUpSpecVersion())
+        }
       ];
       const estimateBulk = await this.estimateFeeBulk(invocations, details);
       return estimateBulk[0];
@@ -20090,7 +20648,10 @@ ${indent}}` : "}";
      * @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) {
@@ -20103,7 +20664,10 @@ ${indent}}` : "}";
     }
     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;
@@ -20410,7 +20974,10 @@ ${indent}}` : "}";
       };
     }
     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 === ETransactionVersion33.F3 || details.version === ETransactionVersion33.V3),
@@ -20756,8 +21323,11 @@ ${indent}}` : "}";
       };
       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,