@btc-vision/btc-runtime 1.4.5 → 1.4.6

package/runtime/storage/Serializable.ts

@@ -5,7 +5,7 @@ import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { Revert } from '../types/Revert';
-import { U256_BYTE_LENGTH } from '../utils/lengths';
+import { U256_BYTE_LENGTH } from '../utils';
 
 // Similar to a struct in Solidity. (Use in worst case scenario, consume a lot of gas)
 export abstract class Serializable {
@@ -54,12 +54,16 @@ export abstract class Serializable {
         if (chunks.length !== this.chunkCount) {
             throw new Revert(
                 'Invalid chunk count, expected ' +
-                    this.chunkCount.toString() +
-                    ' but got ' +
-                    chunks.length.toString(),
+                this.chunkCount.toString() +
+                ' but got ' +
+                chunks.length.toString(),
             );
         }
 
+        if (chunks.length > 255) {
+            throw new Revert('Too many chunks to save. You may only write up to 8160 bytes per object.');
+        }
+
         for (let index: u8 = 0; index < u8(chunks.length); index++) {
             Blockchain.setStorageAt(this.getPointer(this.subPointer, index), chunks[index]);
         }
@@ -69,8 +73,8 @@ export abstract class Serializable {
         const chunks: u256[] = [];
 
         for (let index: i32 = 0; index < buffer.byteLength; index += 32) {
-            if (chunks.length === 255) {
-                throw new Revert('Too many chunks to save');
+            if (chunks.length === 256) {
+                throw new Revert(`Too many chunks to save You may only write up to 8160 bytes per object.`);
             }
 
             const chunk = buffer.slice(index, index + 32);
@@ -81,12 +85,11 @@ export abstract class Serializable {
     }
 
     protected chunksToBytes(chunks: u256[]): BytesReader {
-        if (this.chunkCount >= u8(255)) {
-            //67108863
-            throw new Revert('Too many chunks received');
+        if (this.chunkCount > u8(255)) {
+            throw new Revert(`Too many chunks received. You may only write up to 8160 bytes per object.`);
         }
 
-        const buffer: Uint8Array = new Uint8Array(this.chunkCount * 32);
+        const buffer: Uint8Array = new Uint8Array(i32(this.chunkCount) * i32(32));
         let offset: i32 = 0;
 
         for (let indexChunk: i32 = 0; indexChunk < chunks.length; indexChunk++) {

package/runtime/storage/arrays/StoredAddressArray.ts

@@ -65,7 +65,10 @@ export class StoredAddressArray {
      */
     @inline
     public get(index: u64): Address {
-        assert(index < this._length, 'Index out of bounds');
+        if (index >= this._length) {
+            throw new Revert('Get operation failed: Index out of bounds.');
+        }
+
         const slotIndex: u32 = <u32>index;
         this.ensureValues(slotIndex);
         const value = this._values.get(slotIndex);
@@ -80,7 +83,10 @@ export class StoredAddressArray {
      */
     @inline
     public set(index: u64, value: Address): void {
-        assert(index < this._length, 'Index exceeds current array length');
+        if (index > this.MAX_LENGTH) {
+            throw new Revert('Set operation failed: Index exceeds maximum allowed value.');
+        }
+
         const slotIndex: u32 = <u32>index;
         this.ensureValues(slotIndex);
 
@@ -125,7 +131,7 @@ export class StoredAddressArray {
      * @param {Address} value - The Address to append.
      */
     public push(value: Address): void {
-        if (this._length >= this.MAX_LENGTH) {
+        if (this._length > this.MAX_LENGTH) {
             throw new Revert(
                 'Push operation failed: Array has reached its maximum allowed length.',
             );
@@ -197,37 +203,6 @@ export class StoredAddressArray {
         }
     }
 
-    /**
-     * @method shift
-     * @description Removes the first element of the array.
-     */
-    public shift(): void {
-        if (this._length === 0) {
-            throw new Revert('Shift operation failed: Array is empty.');
-        }
-
-        const currentStartIndex: u64 = this._startIndex;
-        const slotIndex: u32 = <u32>currentStartIndex;
-        this.ensureValues(slotIndex);
-
-        const currentValue = this._values.get(slotIndex);
-        if (currentValue != this.defaultValue) {
-            this._values.set(slotIndex, this.defaultValue);
-            this._isChanged.add(slotIndex);
-        }
-
-        this._length -= 1;
-        this._isChangedLength = true;
-
-        // Increment the startIndex with wrap-around
-        if (this._startIndex < this.MAX_LENGTH - 1) {
-            this._startIndex += 1;
-        } else {
-            this._startIndex = 0;
-        }
-        this._isChangedStartIndex = true;
-    }
-
     /**
      * @method save
      * @description Persists all changes to storage.
@@ -303,7 +278,10 @@ export class StoredAddressArray {
      */
     @inline
     public getAll(startIndex: u32, count: u32): Address[] {
-        assert(startIndex + count <= this._length, 'Requested range exceeds array length');
+        if ((startIndex + count) > this._length) {
+            throw new Revert('Requested range exceeds array length');
+        }
+
         const result: Address[] = new Array<Address>(count);
         for (let i: u32 = 0; i < count; i++) {
             result[i] = this.get(<u64>(startIndex + i));
@@ -383,27 +361,6 @@ export class StoredAddressArray {
         return this._startIndex;
     }
 
-    /**
-     * @method setLength
-     * @description Sets the length of the array, truncating if necessary.
-     * @param {u64} newLength - The new length.
-     */
-    public setLength(newLength: u64): void {
-        if (newLength > this.MAX_LENGTH) {
-            throw new Revert('SetLength operation failed: Length exceeds maximum allowed value.');
-        }
-
-        if (newLength < this._length) {
-            // Truncate the array if newLength is smaller
-            for (let i: u64 = newLength; i < this._length; i++) {
-                this.delete(i);
-            }
-        }
-
-        this._length = newLength;
-        this._isChangedLength = true;
-    }
-
     /**
      * @private
      * @method ensureValues

package/runtime/storage/arrays/StoredBooleanArray.ts

@@ -64,7 +64,9 @@ export class StoredBooleanArray {
      */
     @inline
     public get(index: u64): bool {
-        assert(index < this._length, 'Index out of bounds');
+        if (index >= this._length) {
+            return false;
+        }
 
         const slotIndex: u64 = index / 256; // Each slot holds 256 bits
         const bitIndex: u16 = <u16>(index % 256); // 0 to 255
@@ -85,7 +87,10 @@ export class StoredBooleanArray {
      */
     @inline
     public set(index: u64, value: bool): void {
-        assert(index < this._length, 'Index exceeds current array length');
+        if (index > this.MAX_LENGTH) {
+            throw new Revert('Set operation failed: Index exceeds maximum allowed value.');
+        }
+
         const slotIndex: u64 = index / 256;
         const bitIndex: u16 = <u16>(index % 256);
         this.ensureValues(slotIndex);
@@ -106,7 +111,7 @@ export class StoredBooleanArray {
      * @param {bool} value - The boolean value to append.
      */
     public push(value: bool): void {
-        if (this._length >= this.MAX_LENGTH) {
+        if (this._length > this.MAX_LENGTH) {
             throw new Revert(
                 'Push operation failed: Array has reached its maximum allowed length.',
             );
@@ -158,43 +163,6 @@ export class StoredBooleanArray {
         }
     }
 
-    /**
-     * @method shift
-     * @description Removes the first element of the array by setting it to false, decrementing the length, and incrementing the startIndex.
-     *              If the startIndex reaches the maximum value of u64, it wraps around to 0.
-     */
-    public shift(): void {
-        if (this._length === 0) {
-            throw new Revert('Shift operation failed: Array is empty.');
-        }
-
-        const currentStartIndex: u64 = this._startIndex;
-        const slotIndex: u64 = currentStartIndex / 256;
-        const bitIndex: u16 = <u16>(currentStartIndex % 256);
-        this.ensureValues(slotIndex);
-
-        const slotValue = this._values.get(slotIndex);
-        if (slotValue) {
-            const oldValue = this.getBit(slotValue, bitIndex);
-            if (oldValue != false) {
-                this.setBit(slotValue, bitIndex, false);
-                this._isChanged.add(slotIndex);
-            }
-        }
-
-        // Decrement the length
-        this._length -= 1;
-        this._isChangedLength = true;
-
-        // Increment the startIndex with wrap-around
-        if (this._startIndex < this.MAX_LENGTH - 1) {
-            this._startIndex += 1;
-        } else {
-            this._startIndex = 0;
-        }
-        this._isChangedStartIndex = true;
-    }
-
     /**
      * @method save
      * @description Persists all cached boolean values, the length, and the startIndex to their respective storage slots if any have been modified.
@@ -272,7 +240,9 @@ export class StoredBooleanArray {
      */
     @inline
     public getAll(startIndex: u64, count: u64): bool[] {
-        assert(startIndex + count <= this._length, 'Requested range exceeds array length');
+        if ((startIndex + count) > this._length) {
+            throw new Revert('Requested range exceeds array length');
+        }
 
         if (u32.MAX_VALUE < count) {
             throw new Revert('Requested range exceeds maximum allowed value.');
@@ -366,27 +336,6 @@ export class StoredBooleanArray {
         return this._startIndex;
     }
 
-    /**
-     * @method setLength
-     * @description Sets the length of the array.
-     * @param {u64} newLength - The new length to set.
-     */
-    public setLength(newLength: u64): void {
-        if (newLength > this.MAX_LENGTH) {
-            throw new Revert('SetLength operation failed: Length exceeds maximum allowed value.');
-        }
-
-        if (newLength < this._length) {
-            // Truncate the array if newLength is smaller
-            for (let i: u64 = newLength; i < this._length; i++) {
-                this.delete(i);
-            }
-        }
-
-        this._length = newLength;
-        this._isChangedLength = true;
-    }
-
     /**
      * @method deleteLast
      * @description Deletes the last element of the array by setting it to false and decrementing the length.
@@ -440,7 +389,9 @@ export class StoredBooleanArray {
      * @returns {bool} - The value of the bit at the specified index.
      */
     private getBit(value: u256, bitIndex: u16): bool {
-        assert(bitIndex < 256, 'Bit index out of range');
+        if (!(bitIndex < 256)) {
+            throw new Revert('Bit index out of range');
+        }
 
         if (bitIndex < 64) {
             return ((value.lo1 >> bitIndex) & 0b1) == 1;
@@ -462,7 +413,9 @@ export class StoredBooleanArray {
      * @param {bool} bitValue - The value to set (true or false).
      */
     private setBit(value: u256, bitIndex: u16, bitValue: bool): void {
-        assert(bitIndex < 256, 'Bit index out of range');
+        if (!(bitIndex < 256)) {
+            throw new Revert('Bit index out of range');
+        }
 
         if (bitIndex < 64) {
             const mask = u64(1) << bitIndex;

package/runtime/storage/arrays/StoredU128Array.ts

@@ -64,7 +64,10 @@ export class StoredU128Array {
      */
     @inline
     public get(index: u64): u128 {
-        assert(index < this._length, 'Index out of bounds');
+        if (index >= this._length) {
+            return u128.Zero;
+        }
+
         const slotIndex: u32 = <u32>(index / 2); // Each slot holds two u128s
         const subIndex: u8 = <u8>(index % 2); // 0 or 1
         this.ensureValues(slotIndex);
@@ -84,7 +87,10 @@ export class StoredU128Array {
      */
     @inline
     public set(index: u64, value: u128): void {
-        assert(index < this._length, 'Index exceeds current array length');
+        if (index > this.MAX_LENGTH) {
+            throw new Revert('Set operation failed: Index exceeds maximum allowed value.');
+        }
+
         const slotIndex: u32 = <u32>(index / 2);
         const subIndex: u8 = <u8>(index % 2);
         this.ensureValues(slotIndex);
@@ -103,7 +109,7 @@ export class StoredU128Array {
      * @param {u128} value - The u128 value to append.
      */
     public push(value: u128): void {
-        if (this._length >= this.MAX_LENGTH) {
+        if (this._length > this.MAX_LENGTH) {
             throw new Revert(
                 'Push operation failed: Array has reached its maximum allowed length.',
             );
@@ -155,43 +161,6 @@ export class StoredU128Array {
         }
     }
 
-    /**
-     * @method shift
-     * @description Removes the first element of the array by setting it to zero, decrementing the length, and incrementing the startIndex.
-     *              If the startIndex reaches the maximum value of u64, it wraps around to 0.
-     */
-    public shift(): void {
-        if (this._length === 0) {
-            throw new Revert('Shift operation failed: Array is empty.');
-        }
-
-        const currentStartIndex: u64 = this._startIndex;
-        const slotIndex: u32 = <u32>(currentStartIndex / 2);
-        const subIndex: u8 = <u8>(currentStartIndex % 2);
-        this.ensureValues(slotIndex);
-
-        const slotValues = this._values.get(slotIndex);
-        if (slotValues) {
-            // Set the current start element to zero
-            if (!u128.eq(slotValues[subIndex], u128.Zero)) {
-                slotValues[subIndex] = u128.Zero;
-                this._isChanged.add(slotIndex);
-            }
-        }
-
-        // Decrement the length
-        this._length -= 1;
-        this._isChangedLength = true;
-
-        // Increment the startIndex with wrap-around
-        if (this._startIndex < this.MAX_LENGTH - 1) {
-            this._startIndex += 1;
-        } else {
-            this._startIndex = 0;
-        }
-        this._isChangedStartIndex = true;
-    }
-
     /**
      * @method save
      * @description Persists all cached u128 values, the length, and the startIndex to their respective storage slots if any have been modified.
@@ -280,7 +249,10 @@ export class StoredU128Array {
      */
     @inline
     public getAll(startIndex: u32, count: u32): u128[] {
-        assert(startIndex + count <= this._length, 'Requested range exceeds array length');
+        if ((startIndex + count) > this._length) {
+            throw new Revert('Requested range exceeds array length');
+        }
+
         const result: u128[] = new Array<u128>(count);
         for (let i: u32 = 0; i < count; i++) {
             result[i] = this.get(<u64>(startIndex + i));
@@ -353,25 +325,6 @@ export class StoredU128Array {
         return this._length;
     }
 
-    /**
-     * @method setLength
-     * @description Sets the length of the array.
-     * @param {u64} newLength - The new length to set.
-     */
-    public setLength(newLength: u64): void {
-        if (newLength > this.MAX_LENGTH) {
-            throw new Revert('SetLength operation failed: Length exceeds maximum allowed value.');
-        }
-
-        if (newLength > this._startIndex) {
-            this._startIndex = newLength;
-            this._isChangedStartIndex = true;
-        }
-
-        this._length = newLength;
-        this._isChangedLength = true;
-    }
-
     /**
      * @private
      * @method ensureValues

package/runtime/storage/arrays/StoredU16Array.ts

@@ -64,7 +64,9 @@ export class StoredU16Array {
      */
     @inline
     public get(index: u64): u16 {
-        assert(index < this._length, 'Index out of bounds');
+        if (index >= this._length) {
+            return 0;
+        }
 
         const slotIndex: u64 = index / 16; // Each slot holds sixteen u16s
         const subIndex: u8 = <u8>(index % 16); // 0 to 15
@@ -81,7 +83,10 @@ export class StoredU16Array {
      */
     @inline
     public set(index: u64, value: u16): void {
-        assert(index < this._length, 'Index exceeds current array length');
+        if (index > this.MAX_LENGTH) {
+            throw new Revert('Set operation failed: Index exceeds maximum allowed value.');
+        }
+
         const slotIndex: u64 = index / 16;
         const subIndex: u8 = <u8>(index % 16);
         this.ensureValues(slotIndex);
@@ -99,7 +104,7 @@ export class StoredU16Array {
      * @param {u16} value - The u16 value to append.
      */
     public push(value: u16): void {
-        if (this._length >= this.MAX_LENGTH) {
+        if (this._length > this.MAX_LENGTH) {
             throw new Revert(
                 'Push operation failed: Array has reached its maximum allowed length.',
             );
@@ -148,40 +153,6 @@ export class StoredU16Array {
         }
     }
 
-    /**
-     * @method shift
-     * @description Removes the first element of the array by setting it to zero, decrementing the length, and incrementing the startIndex.
-     *              If the startIndex reaches the maximum value of u64, it wraps around to 0.
-     */
-    public shift(): void {
-        if (this._length === 0) {
-            throw new Revert('Shift operation failed: Array is empty.');
-        }
-
-        const currentStartIndex: u64 = this._startIndex;
-        const slotIndex: u64 = currentStartIndex / 16;
-        const subIndex: u8 = <u8>(currentStartIndex % 16);
-        this.ensureValues(slotIndex);
-
-        const slotValues = this._values.get(slotIndex);
-        if (slotValues && slotValues[subIndex] !== 0) {
-            slotValues[subIndex] = 0;
-            this._isChanged.add(slotIndex);
-        }
-
-        // Decrement the length
-        this._length -= 1;
-        this._isChangedLength = true;
-
-        // Increment the startIndex with wrap-around
-        if (this._startIndex < this.MAX_LENGTH - 1) {
-            this._startIndex += 1;
-        } else {
-            this._startIndex = 0;
-        }
-        this._isChangedStartIndex = true;
-    }
-
     /**
      * @method save
      * @description Persists all cached u16 values, the length, and the startIndex to their respective storage slots if any have been modified.
@@ -257,7 +228,9 @@ export class StoredU16Array {
      */
     @inline
     public getAll(startIndex: u64, count: u64): u16[] {
-        assert(startIndex + count <= this._length, 'Requested range exceeds array length');
+        if ((startIndex + count) > this._length) {
+            throw new Revert('Requested range exceeds array length');
+        }
 
         if (u32.MAX_VALUE < count) {
             throw new Revert('Requested range exceeds maximum allowed value.');
@@ -344,25 +317,6 @@ export class StoredU16Array {
         return this._startIndex;
     }
 
-    /**
-     * @method setLength
-     * @description Sets the length of the array.
-     * @param {u64} newLength - The new length to set.
-     */
-    public setLength(newLength: u64): void {
-        if (newLength > this.MAX_LENGTH) {
-            throw new Revert('SetLength operation failed: Length exceeds maximum allowed value.');
-        }
-
-        if (newLength > this._startIndex) {
-            this._startIndex = newLength;
-            this._isChangedStartIndex = true;
-        }
-
-        this._length = newLength;
-        this._isChangedLength = true;
-    }
-
     public deleteLast(): void {
         if (this._length === 0) {
             throw new Revert('DeleteLast operation failed: Array is empty.');

package/runtime/storage/arrays/StoredU256Array.ts

@@ -19,13 +19,13 @@ export class StoredU256Array {
     private _isChanged: Set<u64> = new Set(); // Set of slotIndexes that are modified
 
     // Internal variables for length and startIndex management
-    private _length: u64 = 0; // Current length of the array
+    private _length: u64 = 0;     // Current length of the array
     private _startIndex: u64 = 0; // Starting index of the array
-    private _isChangedLength: bool = false; // Indicates if the length has been modified
-    private _isChangedStartIndex: bool = false; // Indicates if the startIndex has been modified
+    private _isChangedLength: bool = false;      // Indicates if the length has been modified
+    private _isChangedStartIndex: bool = false;  // Indicates if the startIndex has been modified
 
     // Define a maximum allowed length to prevent excessive storage usage
-    private readonly MAX_LENGTH: u64 = u64(u32.MAX_VALUE - 1); // we need to check what happen in overflow situation to be able to set it to u64.MAX_VALUE
+    private readonly MAX_LENGTH: u64 = u64(u32.MAX_VALUE - 1);
 
     /**
      * @constructor
@@ -52,19 +52,23 @@ export class StoredU256Array {
         this.lengthPointer = lengthPointer;
         this.baseU256Pointer = baseU256Pointer;
 
-        this._length = storedLengthAndStartIndex.lo1; // Bytes 0-7: length
+        this._length = storedLengthAndStartIndex.lo1;  // Bytes 0-7: length
         this._startIndex = storedLengthAndStartIndex.lo2; // Bytes 8-15: startIndex
     }
 
     /**
      * @method get
      * @description Retrieves the u256 value at the specified global index.
+     *              Returns zero instead of reverting if the index is out of bounds.
      * @param {u64} index - The global index (0 to ∞) of the u256 value to retrieve.
-     * @returns {u256} - The u256 value at the specified index.
+     * @returns {u256} - The u256 value at the specified index or zero if out of bounds.
      */
     @inline
     public get(index: u64): u256 {
-        assert(index < this._length, 'Index out of bounds');
+        if (index >= this._length) {
+            return u256.Zero;
+        }
+
         const slotIndex: u32 = <u32>index;
         this.ensureValues(slotIndex);
         const value = this._values.get(slotIndex);
@@ -79,7 +83,10 @@ export class StoredU256Array {
      */
     @inline
     public set(index: u64, value: u256): void {
-        assert(index < this._length, 'Index exceeds current array length');
+        if (index > this.MAX_LENGTH) {
+            throw new Revert('Set operation failed: Index exceeds maximum allowed value.');
+        }
+
         const slotIndex: u32 = <u32>index;
         this.ensureValues(slotIndex);
 
@@ -96,7 +103,7 @@ export class StoredU256Array {
      * @param {u256} value - The u256 value to append.
      */
     public push(value: u256): void {
-        if (this._length >= this.MAX_LENGTH) {
+        if (this._length > this.MAX_LENGTH) {
             throw new Revert(
                 'Push operation failed: Array has reached its maximum allowed length.',
             );
@@ -164,42 +171,10 @@ export class StoredU256Array {
         }
     }
 
-    /**
-     * @method shift
-     * @description Removes the first element of the array by setting it to zero, decrementing the length, and incrementing the startIndex.
-     *              If the startIndex reaches the maximum value of u64, it wraps around to 0.
-     */
-    public shift(): void {
-        if (this._length === 0) {
-            throw new Revert('Shift operation failed: Array is empty.');
-        }
-
-        const currentStartIndex: u64 = this._startIndex;
-        const slotIndex: u32 = <u32>currentStartIndex;
-        this.ensureValues(slotIndex);
-
-        const currentValue = this._values.get(slotIndex);
-        if (!u256.eq(currentValue, u256.Zero)) {
-            this._values.set(slotIndex, u256.Zero);
-            this._isChanged.add(slotIndex);
-        }
-
-        // Decrement the length
-        this._length -= 1;
-        this._isChangedLength = true;
-
-        // Increment the startIndex with wrap-around
-        if (this._startIndex < this.MAX_LENGTH - 1) {
-            this._startIndex += 1;
-        } else {
-            this._startIndex = 0;
-        }
-        this._isChangedStartIndex = true;
-    }
-
     /**
      * @method save
-     * @description Persists all cached u256 values, the length, and the startIndex to their respective storage slots if any have been modified.
+     * @description Persists all cached u256 values, the length, and the startIndex to their respective storage slots
+     *              if any have been modified.
      */
     public save(): void {
         // Save all changed slots
@@ -210,6 +185,7 @@ export class StoredU256Array {
             const value = this._values.get(slotIndex);
             Blockchain.setStorageAt(storagePointer, value);
         }
+
         this._isChanged.clear();
 
         // Save length and startIndex if changed
@@ -239,6 +215,7 @@ export class StoredU256Array {
         // Reset the length and startIndex to zero
         const zeroLengthAndStartIndex = u256.Zero;
         Blockchain.setStorageAt(this.lengthPointer, zeroLengthAndStartIndex);
+
         this._length = 0;
         this._startIndex = 0;
         this._isChangedLength = false;
@@ -272,7 +249,9 @@ export class StoredU256Array {
      */
     @inline
     public getAll(startIndex: u32, count: u32): u256[] {
-        assert(startIndex + count <= this._length, 'Requested range exceeds array length');
+        if ((startIndex + count) > this._length) {
+            throw new Revert('Requested range exceeds array length');
+        }
         const result: u256[] = new Array<u256>(count);
         for (let i: u32 = 0; i < count; i++) {
             result[i] = this.get(<u64>(startIndex + i));
@@ -354,25 +333,6 @@ export class StoredU256Array {
         return this._startIndex;
     }
 
-    /**
-     * @method setLength
-     * @description Sets the length of the array.
-     * @param {u64} newLength - The new length to set.
-     */
-    public setLength(newLength: u64): void {
-        if (newLength > this.MAX_LENGTH) {
-            throw new Revert('SetLength operation failed: Length exceeds maximum allowed value.');
-        }
-
-        if (newLength > this._startIndex) {
-            this._startIndex = newLength;
-            this._isChangedStartIndex = true;
-        }
-
-        this._length = newLength;
-        this._isChangedLength = true;
-    }
-
     /**
      * @private
      * @method ensureValues