starknet 10.1.0 → 10.2.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+# [10.2.0](https://github.com/starknet-io/starknet.js/compare/v10.1.0...v10.2.0) (2026-06-10)
+
+### Features
+
+- in class CairoByteArray hash added. Solve a code cycling ([1ab4c06](https://github.com/starknet-io/starknet.js/commit/1ab4c06884f1decf0317010c4ae97e8ec40d9fd4))
+
 # [10.1.0](https://github.com/starknet-io/starknet.js/compare/v10.0.4...v10.1.0) (2026-06-09)
 
 ### Features

package/README.md

@@ -50,11 +50,11 @@ $ npm install starknet@next
 $ npm install starknet@beta
 ```
 
-Import `starknet` and use the [API](https://www.starknetjs.com/docs/API/).
+Import `starknet` and use the [API](https://starknet-io.github.io/starknet.js/docs/API/).
 
 ## 🌐 Documentation
 
-How to [Guides](https://www.starknetjs.com/docs/guides/intro) :book: & [API](https://www.starknetjs.com/docs/API/) 💻
+How to [Guides](https://starknet-io.github.io/starknet.js/docs/guides/intro) :book: & [API](https://starknet-io.github.io/starknet.js/docs/API/) 💻
 
 Play with [Code Examples](https://github.com/PhilippeR26/starknet.js-workshop-typescript) :video_game:
 

package/dist/index.d.ts

@@ -3613,7 +3613,7 @@ type ParsedEvents = Array<ParsedEvent> & {
 };
 /**
  * Advance formatting used to get js types data as result
- * @description https://starknetjs.com/docs/guides/define_call_message/#formatresponse
+ * @description https://starknet-io.github.io/starknet.js/docs/guides/define_call_message/#formatresponse
  * @example
  * ```typescript
  * // assign custom or existing method to resulting data
@@ -6629,7 +6629,7 @@ type CalcDeployAccountTxHashArgs = CalcV3DeployAccountTxHashArgs;
 declare function calculateDeployAccountTransactionHash$1(args: CalcDeployAccountTxHashArgs): string;
 
 /**
- * Cairo 0 Class Hash computation using Pedersen hash
+ * Pure Pedersen hash utilities — no calldata dependency
  */
 
 declare function computePedersenHash(a: BigNumberish, b: BigNumberish): string;
@@ -6647,6 +6647,11 @@ declare function computePedersenHash(a: BigNumberish, b: BigNumberish): string;
  */
 declare function computeHashOnElements(data: BigNumberish[]): string;
 declare const computePedersenHashOnElements: typeof computeHashOnElements;
+
+/**
+ * Cairo 0 Class Hash computation using Pedersen hash
+ */
+
 /**
  * Calculate contract address from class hash
  *
@@ -9416,6 +9421,22 @@ declare class CairoByteArray {
     toBigInt(): bigint;
     toHexString(): string;
     toBuffer(): any;
+    /**
+     * Compute the Pedersen hash of this ByteArray, following OpenZeppelin's `hash_byte_array` algorithm.
+     *
+     * Serializes the ByteArray to its felt252 components (data array length, each data chunk,
+     * pending_word, pending_word_len), then chains Pedersen hash over all elements starting
+     * from 0, and finalizes with the total element count.
+     *
+     * @returns {string} hex-string felt252 Pedersen hash of the ByteArray
+     * @example
+     * ```typescript
+     * const ba = new CairoByteArray('Hello');
+     * const result = ba.hash();
+     * // result = 0x15d19ad651ffaf8e90a13938db2081fa3ff01de0712e00cbe69891bace66c51
+     * ```
+     */
+    hash(): string;
     /**
      * returns an array of all the data chunks and the pending word
      * when concatenated, represents the original bytes sequence

package/dist/index.global.js

@@ -6261,6 +6261,22 @@ ${indent}}` : "}";
     }
   };
 
+  // src/utils/ec.ts
+  var ec_exports = {};
+  __export(ec_exports, {
+    starkCurve: () => esm_exports4,
+    weierstrass: () => weierstrass_exports
+  });
+
+  // src/utils/hash/pedersenCore.ts
+  function computePedersenHash(a, b) {
+    return esm_exports4.pedersen(BigInt(a), BigInt(b));
+  }
+  function computeHashOnElements2(data) {
+    return [...data, data.length].reduce((x, y) => esm_exports4.pedersen(BigInt(x), BigInt(y)), 0).toString();
+  }
+  var computePedersenHashOnElements = computeHashOnElements2;
+
   // src/utils/errors/rpc.ts
   var errorCodes = {
     FAILED_TO_RECEIVE_TXN: 1,
@@ -6555,6 +6571,31 @@ ${indent}}` : "}";
       const allBytes = concatenateArrayBuffer(this.toElements());
       return buffer_default.from(allBytes);
     }
+    /**
+     * Compute the Pedersen hash of this ByteArray, following OpenZeppelin's `hash_byte_array` algorithm.
+     *
+     * Serializes the ByteArray to its felt252 components (data array length, each data chunk,
+     * pending_word, pending_word_len), then chains Pedersen hash over all elements starting
+     * from 0, and finalizes with the total element count.
+     *
+     * @returns {string} hex-string felt252 Pedersen hash of the ByteArray
+     * @example
+     * ```typescript
+     * const ba = new CairoByteArray('Hello');
+     * const result = ba.hash();
+     * // result = 0x15d19ad651ffaf8e90a13938db2081fa3ff01de0712e00cbe69891bace66c51
+     * ```
+     */
+    hash() {
+      this.assertInitialized();
+      const serialized = [
+        addHexPrefix(this.data.length.toString(16)),
+        ...this.data.flatMap((bytes31) => bytes31.toApiRequest()),
+        ...this.pending_word.toApiRequest(),
+        ...this.pending_word_len.toApiRequest()
+      ];
+      return computeHashOnElements2(serialized);
+    }
     /**
      * returns an array of all the data chunks and the pending word
      * when concatenated, represents the original bytes sequence
@@ -9115,7 +9156,7 @@ ${indent}}` : "}";
     computeCompiledClassHashBlake: () => computeCompiledClassHashBlake,
     computeCompiledClassHashPoseidon: () => computeCompiledClassHashPoseidon,
     computeContractClassHash: () => computeContractClassHash,
-    computeHashOnElements: () => computeHashOnElements3,
+    computeHashOnElements: () => computeHashOnElements2,
     computeHintedClassHash: () => computeHintedClassHash,
     computeLegacyContractClassHash: () => computeLegacyContractClassHash,
     computePedersenHash: () => computePedersenHash,
@@ -9253,22 +9294,13 @@ ${indent}}` : "}";
     calculateL2MessageTxHash: () => calculateL2MessageTxHash,
     calculateTransactionHash: () => calculateTransactionHash,
     calculateTransactionHashCommon: () => calculateTransactionHashCommon2,
-    computeHashOnElements: () => computeHashOnElements2
-  });
-
-  // src/utils/ec.ts
-  var ec_exports = {};
-  __export(ec_exports, {
-    starkCurve: () => esm_exports4,
-    weierstrass: () => weierstrass_exports
+    computeHashOnElements: () => computeHashOnElements3
   });
-
-  // src/utils/hash/transactionHash/v2.ts
-  function computeHashOnElements2(data) {
+  function computeHashOnElements3(data) {
     return [...data, data.length].reduce((x, y) => esm_exports4.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
   }
   function calculateTransactionHashCommon2(txHashPrefix, version, contractAddress, entryPointSelector, calldata, maxFee, chainId, additionalData = []) {
-    const calldataHash = computeHashOnElements2(calldata);
+    const calldataHash = computeHashOnElements3(calldata);
     const dataToHash = [
       txHashPrefix,
       version,
@@ -9279,7 +9311,7 @@ ${indent}}` : "}";
       chainId,
       ...additionalData
     ];
-    return computeHashOnElements2(dataToHash);
+    return computeHashOnElements3(dataToHash);
   }
   function calculateDeclareTransactionHash2(classHash, senderAddress, version, maxFee, chainId, nonce, compiledClassHash) {
     return calculateTransactionHashCommon2(
@@ -9438,18 +9470,11 @@ ${indent}}` : "}";
   }
 
   // src/utils/hash/classHash/pedersen.ts
-  function computePedersenHash(a, b) {
-    return esm_exports4.pedersen(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 calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
     const compiledCalldata = CallData.compile(constructorCalldata);
-    const constructorCalldataHash = computeHashOnElements3(compiledCalldata);
+    const constructorCalldataHash = computeHashOnElements2(compiledCalldata);
     const CONTRACT_ADDRESS_PREFIX = felt("0x535441524b4e45545f434f4e54524143545f41444452455353");
-    const hash = computeHashOnElements3([
+    const hash = computeHashOnElements2([
       CONTRACT_ADDRESS_PREFIX,
       deployerAddress,
       salt,
@@ -9467,21 +9492,21 @@ ${indent}}` : "}";
   function computeLegacyContractClassHash(contract) {
     const compiledContract = isString(contract) ? parse2(contract) : contract;
     const apiVersion = toHex(API_VERSION);
-    const externalEntryPointsHash = computeHashOnElements3(
+    const externalEntryPointsHash = computeHashOnElements2(
       compiledContract.entry_points_by_type.EXTERNAL.flatMap((e) => [e.selector, e.offset])
     );
-    const l1HandlerEntryPointsHash = computeHashOnElements3(
+    const l1HandlerEntryPointsHash = computeHashOnElements2(
       compiledContract.entry_points_by_type.L1_HANDLER.flatMap((e) => [e.selector, e.offset])
     );
-    const constructorEntryPointHash = computeHashOnElements3(
+    const constructorEntryPointHash = computeHashOnElements2(
       compiledContract.entry_points_by_type.CONSTRUCTOR.flatMap((e) => [e.selector, e.offset])
     );
-    const builtinsHash = computeHashOnElements3(
+    const builtinsHash = computeHashOnElements2(
       compiledContract.program.builtins.map((s) => encodeShortString(s))
     );
     const hintedClassHash = computeHintedClassHash(compiledContract);
-    const dataHash = computeHashOnElements3(compiledContract.program.data);
-    return computeHashOnElements3([
+    const dataHash = computeHashOnElements2(compiledContract.program.data);
+    return computeHashOnElements2([
       apiVersion,
       externalEntryPointsHash,
       l1HandlerEntryPointsHash,