starknet 8.5.1 → 8.5.3

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [8.5.3](https://github.com/starknet-io/starknet.js/compare/v8.5.2...v8.5.3) (2025-09-05)
+
+### Bug Fixes
+
+- enforce fixed size for cairo bytes ([6a56166](https://github.com/starknet-io/starknet.js/commit/6a56166e65c79d68e012083cefff3fb532e150ac))
+
+## [8.5.2](https://github.com/starknet-io/starknet.js/compare/v8.5.1...v8.5.2) (2025-08-27)
+
+### Bug Fixes
+
+- preserve leading zeros for cairo bytes data ([5542a00](https://github.com/starknet-io/starknet.js/commit/5542a0015d0cc3cae186d63fe4258c9942ff07d2))
+
 ## [8.5.1](https://github.com/starknet-io/starknet.js/compare/v8.5.0...v8.5.1) (2025-08-27)
 
 ### Bug Fixes

package/dist/index.d.ts

@@ -8513,7 +8513,10 @@ declare class CairoBytes31 {
     toApiRequest(): string[];
     toBigInt(): bigint;
     decodeUtf8(): string;
-    toHexString(): string;
+    /**
+     * @param padded flag for including leading zeros
+     */
+    toHexString(padded?: 'padded'): string;
     static validate(data: Uint8Array | string | Buffer | unknown): void;
     static is(data: Uint8Array | string | Buffer): boolean;
     /**
@@ -8600,6 +8603,15 @@ declare class CairoByteArray {
     toBigInt(): bigint;
     toHexString(): string;
     toBuffer(): any;
+    /**
+     * returns an array of all the data chunks and the pending word
+     * when concatenated, represents the original bytes sequence
+     */
+    toElements(): Uint8Array[];
+    /**
+     * Private helper to check if the CairoByteArray is properly initialized
+     */
+    private assertInitialized;
     static validate(data: Uint8Array | Buffer | BigNumberish | unknown): void;
     /**
      * Check if the provided data is a valid CairoByteArray
@@ -8612,14 +8624,6 @@ declare class CairoByteArray {
      * Check if provided abi type is this data type
      */
     static isAbiType(abiType: string): boolean;
-    /**
-     * Private helper to check if the CairoByteArray is properly initialized
-     */
-    private assertInitialized;
-    /**
-     * Private helper to reconstruct the full byte sequence from chunks and pending word
-     */
-    private reconstructBytes;
     static factoryFromApiResponse(responseIterator: Iterator<string>): CairoByteArray;
 }
 

package/dist/index.global.js

@@ -5323,7 +5323,8 @@ ${indent}}` : "}";
     static abiSelector = "core::felt252";
     constructor(data) {
       _CairoFelt252.validate(data);
-      this.data = _CairoFelt252.__processData(data);
+      const processedData = _CairoFelt252.__processData(data);
+      this.data = processedData.subarray(processedData.findIndex((x) => x > 0));
     }
     static __processData(data) {
       if (isString(data)) {
@@ -5926,7 +5927,9 @@ ${indent}}` : "}";
     static abiSelector = "core::bytes_31::bytes31";
     constructor(data) {
       _CairoBytes31.validate(data);
-      this.data = _CairoBytes31.__processData(data);
+      const processedData = _CairoBytes31.__processData(data);
+      this.data = new Uint8Array(_CairoBytes31.MAX_BYTE_SIZE);
+      this.data.set(processedData, _CairoBytes31.MAX_BYTE_SIZE - processedData.length);
     }
     static __processData(data) {
       if (isString(data)) {
@@ -5947,10 +5950,16 @@ ${indent}}` : "}";
       return uint8ArrayToBigInt(this.data);
     }
     decodeUtf8() {
-      return new TextDecoder().decode(this.data);
+      const cutoff = this.data.findIndex((x) => x > 0);
+      const pruned = this.data.subarray(cutoff >= 0 ? cutoff : Infinity);
+      return new TextDecoder().decode(pruned);
     }
-    toHexString() {
-      return addHexPrefix(this.toBigInt().toString(16));
+    /**
+     * @param padded flag for including leading zeros
+     */
+    toHexString(padded) {
+      const hex = padded === "padded" ? buf2hex(this.data) : this.toBigInt().toString(16);
+      return addHexPrefix(hex);
     }
     static validate(data) {
       const byteLength = _CairoBytes31.__processData(data).length;
@@ -6246,11 +6255,11 @@ ${indent}}` : "}";
       ]);
     }
     decodeUtf8() {
-      const allBytes = this.reconstructBytes();
+      const allBytes = concatenateArrayBuffer(this.toElements());
       return new TextDecoder().decode(allBytes);
     }
     toBigInt() {
-      const allBytes = this.reconstructBytes();
+      const allBytes = concatenateArrayBuffer(this.toElements());
       if (allBytes.length === 0) {
         return 0n;
       }
@@ -6261,15 +6270,39 @@ ${indent}}` : "}";
       return result;
     }
     toHexString() {
-      const allBytes = this.reconstructBytes();
+      const allBytes = concatenateArrayBuffer(this.toElements());
       const hexValue = allBytes.length === 0 ? "0" : buf2hex(allBytes);
       return addHexPrefix(hexValue);
     }
     toBuffer() {
-      this.assertInitialized();
-      const allBytes = this.reconstructBytes();
+      const allBytes = concatenateArrayBuffer(this.toElements());
       return buffer_default.from(allBytes);
     }
+    /**
+     * returns an array of all the data chunks and the pending word
+     * when concatenated, represents the original bytes sequence
+     */
+    toElements() {
+      this.assertInitialized();
+      const allChunks = this.data.flatMap((chunk) => chunk.data);
+      const pendingLen = Number(this.pending_word_len.toBigInt());
+      if (pendingLen) {
+        const pending = new Uint8Array(pendingLen);
+        const paddingDifference = pendingLen - this.pending_word.data.length;
+        pending.set(this.pending_word.data, paddingDifference);
+        allChunks.push(pending);
+      }
+      return allChunks;
+    }
+    /**
+     * Private helper to check if the CairoByteArray is properly initialized
+     */
+    assertInitialized() {
+      assert(
+        this.data && this.pending_word !== void 0 && this.pending_word_len !== void 0,
+        "CairoByteArray is not properly initialized"
+      );
+    }
     static validate(data) {
       assert(data !== null && data !== void 0, "Invalid input: null or undefined");
       assert(
@@ -6317,30 +6350,6 @@ ${indent}}` : "}";
     static isAbiType(abiType) {
       return abiType === _CairoByteArray.abiSelector;
     }
-    /**
-     * Private helper to check if the CairoByteArray is properly initialized
-     */
-    assertInitialized() {
-      assert(
-        this.data && this.pending_word !== void 0 && this.pending_word_len !== void 0,
-        "CairoByteArray is not properly initialized"
-      );
-    }
-    /**
-     * Private helper to reconstruct the full byte sequence from chunks and pending word
-     */
-    reconstructBytes() {
-      this.assertInitialized();
-      const allChunks = this.data.flatMap((chunk) => chunk.data);
-      const pendingLen = Number(this.pending_word_len.toBigInt());
-      if (pendingLen) {
-        const pending = new Uint8Array(pendingLen);
-        const paddingDifference = pendingLen - this.pending_word.data.length;
-        pending.set(this.pending_word.data, paddingDifference);
-        allChunks.push(pending);
-      }
-      return concatenateArrayBuffer(allChunks);
-    }
     static factoryFromApiResponse(responseIterator) {
       const data = Array.from(
         { length: Number(getNext(responseIterator)) },