@btc-vision/btc-runtime 1.3.11 → 1.3.13

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.3.11",
+    "version": "1.3.13",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "scripts": {

package/runtime/contracts/DeployableOP_20.ts

@@ -86,7 +86,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
             throw new Revert('Already initialized');
         }
 
-        if (!skipOwnerVerification) this.onlyOwner(Blockchain.tx.sender);
+        if (!skipOwnerVerification) this.onlyDeployer(Blockchain.tx.sender);
 
         if (params.decimals > 32) {
             throw new Revert('Decimals can not be more than 32');
@@ -237,12 +237,12 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         return this.balanceOfMap.get(owner);
     }
 
-    protected _burn(value: u256, onlyOwner: boolean = true): boolean {
+    protected _burn(value: u256, onlyDeployer: boolean = true): boolean {
         if (u256.eq(value, u256.Zero)) {
             throw new Revert(`No tokens`);
         }
 
-        if (onlyOwner) this.onlyOwner(Blockchain.tx.sender);
+        if (onlyDeployer) this.onlyDeployer(Blockchain.tx.sender);
 
         if (this._totalSupply.value < value) throw new Revert(`Insufficient total supply.`);
         if (!this.balanceOfMap.has(Blockchain.tx.sender)) throw new Revert('No balance');
@@ -260,8 +260,8 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         return true;
     }
 
-    protected _mint(to: Address, value: u256, onlyOwner: boolean = true): boolean {
-        if (onlyOwner) this.onlyOwner(Blockchain.tx.sender);
+    protected _mint(to: Address, value: u256, onlyDeployer: boolean = true): boolean {
+        if (onlyDeployer) this.onlyDeployer(Blockchain.tx.sender);
 
         if (!this.balanceOfMap.has(to)) {
             this.balanceOfMap.set(to, value);
@@ -331,7 +331,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     protected _transferFrom(from: Address, to: Address, value: u256): boolean {
-        if (to === Blockchain.DEAD_ADDRESS || from === Blockchain.DEAD_ADDRESS) {
+        if (from === Blockchain.DEAD_ADDRESS) {
             throw new Revert('Cannot transfer to or from dead address');
         }
 

package/runtime/contracts/OP_NET.ts

@@ -12,8 +12,8 @@ export class OP_NET implements IBTC {
         return Blockchain.contractAddress;
     }
 
-    public get owner(): Address {
-        return Blockchain.owner;
+    public get contractDeployer(): Address {
+        return Blockchain.contractDeployer;
     }
 
     public onDeployment(_calldata: Calldata): void {}
@@ -26,7 +26,7 @@ export class OP_NET implements IBTC {
         switch (method) {
             case encodeSelector('owner'):
                 response = new BytesWriter(ADDRESS_BYTE_LENGTH);
-                response.writeAddress(this.owner);
+                response.writeAddress(this.contractDeployer);
                 break;
             default:
                 throw new Revert('Method not found');
@@ -47,8 +47,8 @@ export class OP_NET implements IBTC {
         return this.address === address;
     }
 
-    protected onlyOwner(caller: Address): void {
-        if (this.owner !== caller) {
+    protected onlyDeployer(caller: Address): void {
+        if (this.contractDeployer !== caller) {
             throw new Revert('Only owner can call this method');
         }
     }

package/runtime/env/BlockchainEnvironment.ts

@@ -87,14 +87,14 @@ export class BlockchainEnvironment {
         return this._nextPointer;
     }
 
-    public _owner: Potential<Address> = null;
+    public _contractDeployer: Potential<Address> = null;
 
-    public get owner(): Address {
-        if (!this._owner) {
-            throw this.error('Owner is required');
+    public get contractDeployer(): Address {
+        if (!this._contractDeployer) {
+            throw this.error('Deployer is required');
         }
 
-        return this._owner as Address;
+        return this._contractDeployer as Address;
     }
 
     public _contractAddress: Potential<Address> = null;
@@ -118,7 +118,7 @@ export class BlockchainEnvironment {
 
         const currentBlock = reader.readU256();
 
-        this._owner = reader.readAddress();
+        this._contractDeployer = reader.readAddress();
         this._contractAddress = reader.readAddress();
 
         const medianTimestamp = reader.readU64();

package/runtime/index.ts

@@ -63,6 +63,7 @@ export * from './memory/Uint8ArrayMerger';
 export * from './storage/StoredU256';
 export * from './storage/StoredU64';
 export * from './storage/StoredU16Array';
+export * from './storage/StoredBooleanArray';
 export * from './storage/StoredU128Array';
 export * from './storage/StoredU256Array';
 export * from './storage/StoredString';

package/runtime/interfaces/IBTC.ts

@@ -1,6 +1,6 @@
 import { Address } from '../types/Address';
 
 export interface IBTC {
-    readonly owner: Address;
+    readonly contractDeployer: Address;
     readonly address: Address;
 }

package/runtime/storage/Serializable.ts

@@ -6,6 +6,7 @@ import { BytesReader } from '../buffer/BytesReader';
 import { Revert } from '../types/Revert';
 import { encodePointer } from '../math/abi';
 
+// Similar to a struct in Solidity. (Use in worst case scenario, consume a lot of gas)
 export abstract class Serializable {
     protected pointer: u16;
     protected subPointer: MemorySlotPointer;
@@ -58,7 +59,7 @@ export abstract class Serializable {
             );
         }
 
-        for (let index: i32 = 0; index < chunks.length; index++) {
+        for (let index: u8 = 0; index < u8(chunks.length); index++) {
             Blockchain.setStorageAt(this.getPointer(this.subPointer, index), chunks[index]);
         }
     }
@@ -79,7 +80,8 @@ export abstract class Serializable {
     }
 
     protected chunksToBytes(chunks: u256[]): BytesReader {
-        if (this.chunkCount >= 67108863) {
+        if (this.chunkCount >= u8(255)) {
+            //67108863
             throw new Revert('Too many chunks received');
         }
 

package/runtime/storage/StoredBooleanArray.ts

@@ -0,0 +1,497 @@
+import { u256 } from 'as-bignum/assembly';
+import { Blockchain } from '../env';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { SafeMath } from '../types/SafeMath';
+import { Revert } from '../types/Revert';
+
+/**
+ * @class StoredBooleanArray
+ * @description Manages an array of boolean values across multiple storage slots. Each slot holds 256 booleans packed into a u256.
+ */
+@final
+export class StoredBooleanArray {
+    private readonly baseU256Pointer: u256;
+    private readonly lengthPointer: u256;
+
+    // Internal cache for storage slots
+    private _values: Map<u64, u256> = new Map(); // Map from slotIndex to u256
+    private _isLoaded: Set<u64> = new Set(); // Set of slotIndexes that are loaded
+    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 _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
+
+    // Define a maximum allowed length to prevent excessive storage usage
+    private readonly MAX_LENGTH: u64 = u32.MAX_VALUE;
+
+    /**
+     * @constructor
+     * @param {u16} pointer - The primary pointer identifier.
+     * @param {Uint8Array} subPointer - The sub-pointer for memory slot addressing.
+     * @param {u256} defaultValue - The default u256 value if storage is uninitialized.
+     */
+    constructor(
+        public pointer: u16,
+        public subPointer: Uint8Array,
+        private defaultValue: u256,
+    ) {
+        // Initialize the base u256 pointer using the primary pointer and subPointer
+        const writer = new BytesWriter(32);
+        writer.writeU16(pointer);
+        writer.writeBytes(subPointer);
+
+        // Initialize the base and length pointers
+        const baseU256Pointer = u256.fromBytes(writer.getBuffer(), true);
+        const lengthPointer = baseU256Pointer.clone();
+
+        // Load the current length and startIndex from storage
+        const storedLengthAndStartIndex: u256 = Blockchain.getStorageAt(lengthPointer, u256.Zero);
+        this.lengthPointer = lengthPointer;
+        this.baseU256Pointer = baseU256Pointer;
+
+        this._length = storedLengthAndStartIndex.lo1; // Bytes 0-7: length
+        this._startIndex = storedLengthAndStartIndex.lo2; // Bytes 8-15: startIndex
+    }
+
+    /**
+     * @method get
+     * @description Retrieves the boolean value at the specified global index.
+     * @param {u64} index - The global index (0 to ∞) of the boolean value to retrieve.
+     * @returns {bool} - The boolean value at the specified index.
+     */
+    @inline
+    public get(index: u64): bool {
+        assert(index < this._length, 'Index out of bounds');
+
+        const slotIndex: u64 = index / 256; // Each slot holds 256 bits
+        const bitIndex: u16 = <u16>(index % 256); // 0 to 255
+        this.ensureValues(slotIndex);
+        const slotValue = this._values.get(slotIndex);
+        if (slotValue) {
+            return this.getBit(slotValue, bitIndex);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * @method set
+     * @description Sets the boolean value at the specified global index.
+     * @param {u64} index - The global index (0 to ∞) of the boolean value to set.
+     * @param {bool} value - The boolean value to assign.
+     */
+    @inline
+    public set(index: u64, value: bool): void {
+        assert(index < this._length, 'Index exceeds current array length');
+        const slotIndex: u64 = index / 256;
+        const bitIndex: u16 = <u16>(index % 256);
+        this.ensureValues(slotIndex);
+
+        const slotValue = this._values.get(slotIndex);
+        if (slotValue) {
+            const oldValue = this.getBit(slotValue, bitIndex);
+            if (oldValue != value) {
+                this.setBit(slotValue, bitIndex, value);
+                this._isChanged.add(slotIndex);
+            }
+        }
+    }
+
+    /**
+     * @method push
+     * @description Appends a new boolean value to the end of the array.
+     * @param {bool} value - The boolean value to append.
+     */
+    public push(value: bool): void {
+        if (this._length >= this.MAX_LENGTH) {
+            throw new Revert(
+                'Push operation failed: Array has reached its maximum allowed length.',
+            );
+        }
+
+        const newIndex: u64 = this._length;
+        const effectiveIndex: u64 = this._startIndex + newIndex;
+        const wrappedIndex: u64 =
+            effectiveIndex < this.MAX_LENGTH ? effectiveIndex : effectiveIndex % this.MAX_LENGTH;
+        const slotIndex: u64 = wrappedIndex / 256;
+        const bitIndex: u8 = <u8>(wrappedIndex % 256);
+
+        // Ensure the slot is loaded
+        this.ensureValues(slotIndex);
+
+        // Set the new value
+        const slotValue = this._values.get(slotIndex);
+        if (slotValue) {
+            this.setBit(slotValue, bitIndex, value);
+            this._isChanged.add(slotIndex);
+        }
+
+        // Increment the length
+        this._length += 1;
+        this._isChangedLength = true;
+    }
+
+    /**
+     * @method delete
+     * @description Deletes the boolean value at the specified index by setting it to false. Does not reorder the array.
+     * @param {u64} index - The global index of the boolean value to delete.
+     */
+    public delete(index: u64): void {
+        if (index >= this._length) {
+            throw new Revert('Delete operation failed: Index out of bounds.');
+        }
+
+        const slotIndex: u64 = index / 256;
+        const bitIndex: u16 = <u16>(index % 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);
+            }
+        }
+    }
+
+    /**
+     * @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.
+     */
+    public save(): void {
+        // Save all changed slots
+        const values = this._isChanged.values();
+        for (let i = 0; i < values.length; i++) {
+            const slotIndex = values[i];
+            const slotValue = this._values.get(slotIndex);
+            if (slotValue) {
+                const storagePointer = this.calculateStoragePointer(slotIndex);
+                Blockchain.setStorageAt(storagePointer, slotValue);
+            }
+        }
+        this._isChanged.clear();
+
+        // Save length and startIndex if changed
+        if (this._isChangedLength || this._isChangedStartIndex) {
+            const packedLengthAndStartIndex = new u256();
+            packedLengthAndStartIndex.lo1 = this._length;
+            packedLengthAndStartIndex.lo2 = this._startIndex;
+            Blockchain.setStorageAt(this.lengthPointer, packedLengthAndStartIndex);
+            this._isChangedLength = false;
+            this._isChangedStartIndex = false;
+        }
+    }
+
+    /**
+     * @method deleteAll
+     * @description Deletes all storage slots by setting them to zero, including the length and startIndex slots.
+     */
+    public deleteAll(): void {
+        // Iterate over all loaded slots and clear them
+        const keys = this._values.keys();
+        for (let i = 0; i < keys.length; i++) {
+            const slotIndex = keys[i];
+            const storagePointer = this.calculateStoragePointer(slotIndex);
+            Blockchain.setStorageAt(storagePointer, u256.Zero);
+        }
+
+        // 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;
+        this._isChangedStartIndex = false;
+
+        // Clear internal caches
+        this._values.clear();
+        this._isLoaded.clear();
+        this._isChanged.clear();
+    }
+
+    /**
+     * @method setMultiple
+     * @description Sets multiple boolean values starting from a specific global index.
+     * @param {u64} startIndex - The starting global index.
+     * @param {bool[]} values - An array of boolean values to set.
+     */
+    @inline
+    public setMultiple(startIndex: u64, values: bool[]): void {
+        for (let i: u64 = 0; i < values.length; i++) {
+            this.set(startIndex + i, values[i]);
+        }
+    }
+
+    /**
+     * @method getAll
+     * @description Retrieves a range of boolean values starting from a specific global index.
+     * @param {u64} startIndex - The starting global index.
+     * @param {u64} count - The number of boolean values to retrieve.
+     * @returns {bool[]} - An array containing the retrieved boolean values.
+     */
+    @inline
+    public getAll(startIndex: u64, count: u64): bool[] {
+        assert(startIndex + count <= this._length, 'Requested range exceeds array length');
+
+        if (u32.MAX_VALUE < count) {
+            throw new Revert('Requested range exceeds maximum allowed value.');
+        }
+
+        const result: bool[] = new Array<bool>(count as u32);
+        for (let i: u64 = 0; i < count; i++) {
+            result[i as u32] = this.get(startIndex + i);
+        }
+        return result;
+    }
+
+    /**
+     * @method toString
+     * @description Returns a string representation of all cached boolean values.
+     * @returns {string} - A string in the format "[true, false, ..., true]".
+     */
+    @inline
+    public toString(): string {
+        let str = '[';
+        for (let i: u64 = 0; i < this._length; i++) {
+            const value = this.get(i);
+            str += value.toString();
+            if (i !== this._length - 1) {
+                str += ', ';
+            }
+        }
+        str += ']';
+        return str;
+    }
+
+    /**
+     * @method toBytes
+     * @description Returns the packed u256 values as a byte array.
+     * @returns {u8[]} - The packed u256 values in byte form.
+     */
+    @inline
+    public toBytes(): u8[] {
+        const bytes: u8[] = new Array<u8>();
+        const slotCount: u64 = (this._length + 255) / 256;
+
+        for (let slotIndex: u64 = 0; slotIndex < slotCount; slotIndex++) {
+            this.ensureValues(slotIndex);
+            const slotValue = this._values.get(slotIndex);
+            if (slotValue) {
+                const slotBytes = slotValue.toBytes();
+                for (let i: u32 = 0; i < slotBytes.length; i++) {
+                    bytes.push(slotBytes[i]);
+                }
+            }
+        }
+        return bytes;
+    }
+
+    /**
+     * @method reset
+     * @description Resets all cached boolean values to false and marks them as changed, including resetting the length and startIndex.
+     */
+    @inline
+    public reset(): void {
+        // Reset the length and startIndex to zero
+        this._length = 0;
+        this._startIndex = 0;
+        this._isChangedLength = true;
+        this._isChangedStartIndex = true;
+
+        // Clear internal caches
+        this._values.clear();
+        this._isLoaded.clear();
+        this._isChanged.clear();
+
+        this.save();
+    }
+
+    /**
+     * @method getLength
+     * @description Retrieves the current length of the array.
+     * @returns {u64} - The current length.
+     */
+    @inline
+    public getLength(): u64 {
+        return this._length;
+    }
+
+    /**
+     * @method startingIndex
+     * @description Retrieves the current starting index of the array.
+     * @returns {u64} - The starting index.
+     */
+    public startingIndex(): u64 {
+        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.
+     */
+    public deleteLast(): void {
+        if (this._length === 0) {
+            throw new Revert('DeleteLast operation failed: Array is empty.');
+        }
+
+        const index = this._length - 1;
+        this.delete(index);
+
+        // Decrement the length
+        this._length -= 1;
+        this._isChangedLength = true;
+    }
+
+    /**
+     * @private
+     * @method ensureValues
+     * @description Loads and caches the u256 value from the specified storage slot.
+     * @param {u64} slotIndex - The index of the storage slot.
+     */
+    private ensureValues(slotIndex: u64): void {
+        if (!this._isLoaded.has(slotIndex)) {
+            const storagePointer = this.calculateStoragePointer(slotIndex);
+            const storedU256: u256 = Blockchain.getStorageAt(storagePointer, this.defaultValue);
+            this._values.set(slotIndex, storedU256);
+            this._isLoaded.add(slotIndex);
+        }
+    }
+
+    /**
+     * @private
+     * @method calculateStoragePointer
+     * @description Calculates the storage pointer for a given slot index by incrementing the base pointer.
+     * @param {u64} slotIndex - The index of the storage slot.
+     * @returns {u256} - The calculated storage pointer.
+     */
+    private calculateStoragePointer(slotIndex: u64): u256 {
+        // Each slot is identified by baseU256Pointer + slotIndex + 1
+        return SafeMath.add(this.baseU256Pointer, u256.fromU64(slotIndex + 1));
+    }
+
+    /**
+     * @private
+     * @method getBit
+     * @description Retrieves the bit value at the specified bit index from the u256 value.
+     * @param {u256} value - The u256 value containing the bits.
+     * @param {u16} bitIndex - The index of the bit to retrieve (0-255).
+     * @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 < 64) {
+            return ((value.lo1 >> bitIndex) & 0b1) == 1;
+        } else if (bitIndex < 128) {
+            return ((value.lo2 >> (bitIndex - 64)) & 0b1) == 1;
+        } else if (bitIndex < 192) {
+            return ((value.hi1 >> (bitIndex - 128)) & 0b1) == 1;
+        } else {
+            return ((value.hi2 >> (bitIndex - 192)) & 0b1) == 1;
+        }
+    }
+
+    /**
+     * @private
+     * @method setBit
+     * @description Sets the bit value at the specified bit index in the u256 value.
+     * @param {u256} value - The u256 value containing the bits.
+     * @param {u16} bitIndex - The index of the bit to set (0-255).
+     * @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 < 64) {
+            const mask = u64(1) << bitIndex;
+            if (bitValue) {
+                value.lo1 |= mask;
+            } else {
+                value.lo1 &= ~mask;
+            }
+        } else if (bitIndex < 128) {
+            const mask = u64(1) << (bitIndex - 64);
+            if (bitValue) {
+                value.lo2 |= mask;
+            } else {
+                value.lo2 &= ~mask;
+            }
+        } else if (bitIndex < 192) {
+            const mask = u64(1) << (bitIndex - 128);
+            if (bitValue) {
+                value.hi1 |= mask;
+            } else {
+                value.hi1 &= ~mask;
+            }
+        } else {
+            const mask = u64(1) << (bitIndex - 192);
+            if (bitValue) {
+                value.hi2 |= mask;
+            } else {
+                value.hi2 &= ~mask;
+            }
+        }
+    }
+}

package/runtime/storage/StoredU128Array.ts

@@ -25,7 +25,7 @@ export class StoredU128Array {
     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.MAX_VALUE - 1;
+    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
 
     /**
      * @constructor
@@ -246,6 +246,19 @@ export class StoredU128Array {
         this._isChanged.clear();
     }
 
+    public deleteLast(): void {
+        if (this._length === 0) {
+            throw new Revert('DeleteLast operation failed: Array is empty.');
+        }
+
+        const lastIndex = this._length - 1;
+        this.delete(lastIndex);
+
+        // Decrement the length
+        this._length -= 1;
+        this._isChangedLength = true;
+    }
+
     /**
      * @method setMultiple
      * @description Sets multiple u128 values starting from a specific global index.

package/runtime/storage/StoredU16Array.ts

@@ -25,7 +25,7 @@ export class StoredU16Array {
     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.MAX_VALUE - 1;
+    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
 
     /**
      * @constructor
@@ -258,9 +258,14 @@ export class StoredU16Array {
     @inline
     public getAll(startIndex: u64, count: u64): u16[] {
         assert(startIndex + count <= this._length, 'Requested range exceeds array length');
-        const result: u16[] = new Array<u16>(count);
+
+        if (u32.MAX_VALUE < count) {
+            throw new Revert('Requested range exceeds maximum allowed value.');
+        }
+
+        const result: u16[] = new Array<u16>(count as u32);
         for (let i: u64 = 0; i < count; i++) {
-            result[i] = this.get(startIndex + i);
+            result[i as u32] = this.get(startIndex + i);
         }
         return result;
     }
@@ -360,6 +365,19 @@ export class StoredU16Array {
         this._isChangedLength = true;
     }
 
+    public deleteLast(): void {
+        if (this._length === 0) {
+            throw new Revert('DeleteLast operation failed: Array is empty.');
+        }
+
+        const index = this._length - 1;
+        this.delete(index);
+
+        // Decrement the length
+        this._length -= 1;
+        this._isChangedLength = true;
+    }
+
     /**
      * @private
      * @method ensureValues

package/runtime/storage/StoredU256Array.ts

@@ -25,7 +25,7 @@ export class StoredU256Array {
     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.MAX_VALUE - 1;
+    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
 
     /**
      * @constructor
@@ -120,6 +120,31 @@ export class StoredU256Array {
         this._isChangedLength = true;
     }
 
+    public deleteLast(): void {
+        if (this._length === 0) {
+            throw new Revert('Delete operation failed: Array is empty.');
+        }
+
+        const lastIndex: u64 = this._length - 1;
+        const slotIndex: u32 = <u32>(this._startIndex + lastIndex);
+        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;
+    }
+
+    public setStartingIndex(index: u64): void {
+        this._startIndex = index;
+        this._isChangedStartIndex = true;
+    }
+
     /**
      * @method delete
      * @description Deletes the u256 value at the specified index by setting it to zero. Does not reorder the array.