@btc-vision/btc-runtime 1.3.14 → 1.3.16

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.3.14",
+    "version": "1.3.16",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "scripts": {
@@ -43,8 +43,8 @@
     ],
     "dependencies": {
         "@assemblyscript/loader": "^0.27.30",
+        "@btc-vision/as-bignum": "^0.0.2",
         "@eslint/js": "^9.10.0",
-        "as-bignum": "^0.3.1",
         "gulplog": "^2.2.0",
         "mocha": "^10.7.3",
         "ts-node": "^10.9.2",

package/runtime/buffer/BytesReader.ts

@@ -1,6 +1,6 @@
 import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { Selector } from '../math/abi';
-import { i128, u128, u256 } from 'as-bignum/assembly';
+import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
 import { Revert } from '../types/Revert';
 import { TransactionInput, TransactionOutput } from '../env/classes/UTXO';
 import { i256 } from '../math/i256';

package/runtime/buffer/BytesWriter.ts

@@ -1,4 +1,4 @@
-import { i128, u128, u256 } from 'as-bignum/assembly';
+import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
 import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { Selector } from '../math/abi';
 import { BytesReader } from './BytesReader';

package/runtime/contracts/DeployableOP_20.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { ApproveEvent, BurnEvent, MintEvent, TransferEvent } from '../events/predefined';

package/runtime/contracts/OP_20.ts

@@ -1,5 +1,5 @@
 import { DeployableOP_20 } from './DeployableOP_20';
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { OP20InitParameters } from './interfaces/OP20InitParameters';
 
 export abstract class OP_20 extends DeployableOP_20 {

package/runtime/contracts/interfaces/OP20InitParameters.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 
 export class OP20InitParameters {
     readonly maxSupply: u256;

package/runtime/env/BlockchainEnvironment.ts

@@ -1,7 +1,7 @@
 import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { MemorySlotData } from '../memory/MemorySlot';
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesReader } from '../buffer/BytesReader';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { NetEvent } from '../events/NetEvent';
@@ -10,13 +10,11 @@ import { OP_NET } from '../contracts/OP_NET';
 import { PointerStorage } from '../types';
 import {
     callContract,
-    deploy,
     deployFromAddress,
     emit,
     encodeAddress,
     loadPointer,
     log,
-    nextPointerGreaterThan,
     storePointer,
     validateBitcoinAddress,
     verifySchnorrSignature,
@@ -186,7 +184,7 @@ export class BlockchainEnvironment {
         return reader.readAddress();
     }
 
-    public deployContract(hash: u256, bytecode: Uint8Array): DeployContractResponse {
+    /*public deployContract(hash: u256, bytecode: Uint8Array): DeployContractResponse {
         const writer = new BytesWriter(32 + bytecode.length);
         writer.writeU256(hash);
         writer.writeBytes(bytecode);
@@ -199,7 +197,7 @@ export class BlockchainEnvironment {
         const contractAddress: Address = reader.readAddress();
 
         return new DeployContractResponse(virtualAddress, contractAddress);
-    }
+    }*/
 
     public deployContractFromExisting(
         existingAddress: Address,
@@ -220,6 +218,7 @@ export class BlockchainEnvironment {
         return new DeployContractResponse(virtualAddress, contractAddress);
     }
 
+    // TODO: Change MemorySlotData type to a Uint8Array instead of a u256.
     public getStorageAt(
         pointerHash: MemorySlotPointer,
         defaultValue: MemorySlotData<u256>,
@@ -233,7 +232,7 @@ export class BlockchainEnvironment {
         return defaultValue;
     }
 
-    public getNextPointerGreaterThan(
+    /*public getNextPointerGreaterThan(
         targetPointer: MemorySlotPointer,
         valueAtLeast: u256,
         lte: boolean = true,
@@ -247,7 +246,7 @@ export class BlockchainEnvironment {
         const reader: BytesReader = new BytesReader(result);
 
         return reader.readU256();
-    }
+    }*/
 
     public verifySchnorrSignature(
         publicKey: Address,
@@ -265,6 +264,7 @@ export class BlockchainEnvironment {
         return reader.readBoolean();
     }
 
+    // TODO: Change MemorySlotData type to a Uint8Array instead of a u256.
     public hasStorageAt(pointerHash: MemorySlotPointer): bool {
         // We mark zero as the default value for the storage, if something is 0, the storage slot get deleted or is non-existent
         const val: u256 = this.getStorageAt(pointerHash, u256.Zero);

package/runtime/env/classes/Block.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 
 @final
 export class Block {

package/runtime/events/predefined/ApproveEvent.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Address, ADDRESS_BYTE_LENGTH } from '../../types/Address';
 import { NetEvent } from '../NetEvent';
 import { BytesWriter } from '../../buffer/BytesWriter';

package/runtime/events/predefined/BurnEvent.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { NetEvent } from '../NetEvent';
 import { BytesWriter } from '../../buffer/BytesWriter';
 

package/runtime/events/predefined/ClaimEvent.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { NetEvent } from '../NetEvent';
 import { BytesWriter } from '../../buffer/BytesWriter';
 

package/runtime/events/predefined/MintEvent.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { NetEvent } from '../NetEvent';
 import { BytesWriter } from '../../buffer/BytesWriter';
 import { Address, ADDRESS_BYTE_LENGTH } from '../../types/Address';

package/runtime/events/predefined/StakeEvent.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { NetEvent } from '../NetEvent';
 import { BytesWriter } from '../../buffer/BytesWriter';
 

package/runtime/events/predefined/TransferEvent.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { NetEvent } from '../NetEvent';
 import { Address, ADDRESS_BYTE_LENGTH } from '../../types/Address';
 import { BytesWriter } from '../../buffer/BytesWriter';

package/runtime/events/predefined/UnstakeEvent.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { NetEvent } from '../NetEvent';
 import { BytesWriter } from '../../buffer/BytesWriter';
 

package/runtime/generic/MapU256.ts

@@ -1,5 +1,5 @@
 import { Revert } from '../types/Revert';
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Map } from './Map';
 
 export class MapU256 extends Map<u256, u256> {

package/runtime/index.ts

@@ -70,6 +70,7 @@ export * from './storage/StoredString';
 export * from './storage/StoredAddress';
 export * from './storage/StoredBoolean';
 export * from './storage/Serializable';
+export * from './storage/StoredAddressArray';
 
 export * from './storage/StorageBacked';
 export * from './storage/StorageSlot';

package/runtime/interfaces/DeployContractResponse.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Address } from '../types/Address';
 
 export class DeployContractResponse {

package/runtime/math/bytes.ts

@@ -1,4 +1,4 @@
-import { u128, u256 } from 'as-bignum/assembly';
+import { u128, u256 } from '@btc-vision/as-bignum/assembly';
 
 export function bytes(number: u256[]): Uint8Array {
     const result = new Uint8Array(32 * number.length);

package/runtime/math/i256.ts

@@ -1,4 +1,4 @@
-import { i128, u128, u256 } from 'as-bignum/assembly';
+import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
 
 export class i256 {
 

package/runtime/math/u160.ts

@@ -1,4 +1,4 @@
-import { i128, u128 } from 'as-bignum/assembly';
+import { i128, u128 } from '@btc-vision/as-bignum/assembly';
 import { __carry, __uadd64, __umulh64 } from 'as-bignum/assembly/globals';
 
 @lazy const HEX_CHARS = '0123456789abcdef';

package/runtime/memory/AddressMemoryMap.ts

@@ -2,7 +2,7 @@ import { MemorySlotPointer } from './MemorySlotPointer';
 import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
 import { MemorySlotData } from './MemorySlot';
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { Address } from '../types/Address';
 

package/runtime/memory/KeyMerger.ts

@@ -1,5 +1,5 @@
 import { MemorySlotData } from './MemorySlot';
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Blockchain } from '../env';
 import { MemorySlotPointer } from './MemorySlotPointer';
 import { encodePointer } from '../math/abi';

package/runtime/memory/MemorySlotPointer.ts

@@ -1,3 +1,3 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 
 export type MemorySlotPointer = u256;

package/runtime/memory/MultiAddressMemoryMap.ts

@@ -1,5 +1,5 @@
 import { MemorySlotData } from './MemorySlot';
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Uint8ArrayMerger } from './Uint8ArrayMerger';
 import { Address } from '../types/Address';
 

package/runtime/memory/MultiStringMemoryMap.ts

@@ -1,5 +1,5 @@
 import { MemorySlotData } from './MemorySlot';
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { KeyMerger } from './KeyMerger';
 
 @final

package/runtime/memory/StringMemoryMap.ts

@@ -2,7 +2,7 @@ import { MemorySlotPointer } from './MemorySlotPointer';
 import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
 import { MemorySlotData } from './MemorySlot';
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesWriter } from '../buffer/BytesWriter';
 
 @final

package/runtime/memory/Uint8ArrayMerger.ts

@@ -1,5 +1,5 @@
 import { MemorySlotData } from './MemorySlot';
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Blockchain } from '../env';
 import { MemorySlotPointer } from './MemorySlotPointer';
 import { encodePointer } from '../math/abi';

package/runtime/secp256k1/ECPoint.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { SafeMath } from '../types/SafeMath';
 
 // secp256k1 curve parameters (using little-endian byte arrays)

package/runtime/shared-libraries/OP20Utils.ts

@@ -1,5 +1,5 @@
 import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { encodeSelector, Selector } from '../math/abi';

package/runtime/shared-libraries/TransferHelper.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { encodeSelector, Selector } from '../math/abi';
 import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { BytesWriter } from '../buffer/BytesWriter';

package/runtime/storage/Serializable.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Blockchain } from '../env';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { BytesWriter } from '../buffer/BytesWriter';

package/runtime/storage/StorageBacked.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 
 export interface StorageBacked {
     serialize(): Array<u256>;

package/runtime/storage/StorageSlot.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BlockchainEnvironment } from '../env/BlockchainEnvironment';
 import { Sha256 } from '../math/sha256';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';

package/runtime/storage/StorageValue.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { StorageSlot } from './StorageSlot';
 
 export class StorageValue<T> {

package/runtime/storage/StoredAddress.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';

package/runtime/storage/StoredAddressArray.ts

@@ -0,0 +1,437 @@
+import { u256 } from '@btc-vision/as-bignum/assembly';
+import { Blockchain } from '../env';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { SafeMath } from '../types/SafeMath';
+import { Address } from '../types/Address';
+import { Revert } from '../types/Revert';
+
+/**
+ * @class StoredAddressArray
+ * @description Manages an array of Address values across multiple storage slots.
+ * Each slot holds one Address (stored as u256 in storage).
+ */
+@final
+export class StoredAddressArray {
+    private readonly baseU256Pointer: u256;
+    private readonly lengthPointer: u256;
+
+    // Internal cache for storage slots
+    private _values: Map<u64, Address> = new Map(); // Map from slotIndex to Address value
+    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 = u64(u32.MAX_VALUE - 1);
+
+    /**
+     * @constructor
+     * @param {u16} pointer - The primary pointer identifier.
+     * @param {Uint8Array} subPointer - The sub-pointer for memory slot addressing.
+     * @param {Address} defaultValue - The default Address value if storage is uninitialized.
+     */
+    constructor(
+        public pointer: u16,
+        public subPointer: Uint8Array,
+        private defaultValue: Address,
+    ) {
+        // Initialize the base pointer
+        const writer = new BytesWriter(32);
+        writer.writeU16(pointer);
+        writer.writeBytes(subPointer);
+
+        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 Address value at the specified global index.
+     * @param {u64} index - The global index of the Address to retrieve.
+     * @returns {Address} - The Address value at the specified index.
+     */
+    @inline
+    public get(index: u64): Address {
+        assert(index < this._length, 'Index out of bounds');
+        const slotIndex: u32 = <u32>index;
+        this.ensureValues(slotIndex);
+        const value = this._values.get(slotIndex);
+        return value ? value : this.defaultValue;
+    }
+
+    /**
+     * @method set
+     * @description Sets the Address value at the specified global index.
+     * @param {u64} index - The global index of the Address to set.
+     * @param {Address} value - The Address value to assign.
+     */
+    @inline
+    public set(index: u64, value: Address): void {
+        assert(index < this._length, 'Index exceeds current array length');
+        const slotIndex: u32 = <u32>index;
+        this.ensureValues(slotIndex);
+
+        const currentValue = this._values.get(slotIndex);
+        if (currentValue != value) {
+            this._values.set(slotIndex, value);
+            this._isChanged.add(slotIndex);
+        }
+    }
+
+    /**
+     * @method indexOf
+     * @description Searches for the first occurrence of the specified Address value and returns its index.
+     * @param {Address} value - The Address to locate.
+     * @returns {i64} - The index of the first occurrence, or -1 if not found.
+     */
+    @inline
+    public indexOf(value: Address): i64 {
+        for (let i: u64 = 0; i < this._length; i++) {
+            const currentValue = this.get(i);
+            if (currentValue == value) {
+                return i64(i);
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * @method contains
+     * @description Determines whether the array contains the specified Address value.
+     * @param {Address} value - The Address to locate.
+     * @returns {boolean} - True if found; otherwise, false.
+     */
+    @inline
+    public contains(value: Address): boolean {
+        return this.indexOf(value) !== -1;
+    }
+
+    /**
+     * @method push
+     * @description Appends a new Address value to the end of the array.
+     * @param {Address} value - The Address to append.
+     */
+    public push(value: Address): 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 wrappedIndex: u64 =
+            newIndex < this.MAX_LENGTH ? newIndex : newIndex % this.MAX_LENGTH;
+        const slotIndex: u32 = <u32>wrappedIndex;
+
+        this.ensureValues(slotIndex);
+        this._values.set(slotIndex, value);
+        this._isChanged.add(slotIndex);
+
+        this._length += 1;
+        this._isChangedLength = true;
+    }
+
+    /**
+     * @method deleteLast
+     * @description Deletes the last element from the array.
+     */
+    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 (currentValue != this.defaultValue) {
+            this._values.set(slotIndex, this.defaultValue);
+            this._isChanged.add(slotIndex);
+        }
+
+        this._length -= 1;
+        this._isChangedLength = true;
+    }
+
+    /**
+     * @method setStartingIndex
+     * @description Sets the starting index of the array.
+     * @param {u64} index - The new starting index.
+     */
+    public setStartingIndex(index: u64): void {
+        this._startIndex = index;
+        this._isChangedStartIndex = true;
+    }
+
+    /**
+     * @method delete
+     * @description Deletes the Address value at the specified index by setting it to defaultValue.
+     * @param {u64} index - The global index of the Address value to delete.
+     */
+    public delete(index: u64): void {
+        if (index >= this._length) {
+            throw new Revert('Delete operation failed: Index out of bounds.');
+        }
+
+        const slotIndex: u32 = <u32>index;
+        this.ensureValues(slotIndex);
+
+        const currentValue = this._values.get(slotIndex);
+        if (currentValue != this.defaultValue) {
+            this._values.set(slotIndex, this.defaultValue);
+            this._isChanged.add(slotIndex);
+        }
+    }
+
+    /**
+     * @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.
+     */
+    public save(): void {
+        // Save all changed slots
+        const changed = this._isChanged.values();
+        for (let i = 0; i < changed.length; i++) {
+            const slotIndex = changed[i];
+            const storagePointer = this.calculateStoragePointer(slotIndex);
+            const value = this._values.get(slotIndex);
+            Blockchain.setStorageAt(storagePointer, u256.fromBytes(value));
+        }
+        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 the entire array and resets length and startIndex.
+     */
+    public deleteAll(): void {
+        // Clear all loaded slots
+        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.fromBytes(this.defaultValue));
+        }
+
+        // Reset the length and startIndex
+        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 Address values starting from a specific global index.
+     * @param {u32} startIndex - The starting global index.
+     * @param {Address[]} values - An array of Address values to set.
+     */
+    @inline
+    public setMultiple(startIndex: u32, values: Address[]): void {
+        for (let i: u32 = 0; i < values.length; i++) {
+            this.set(<u64>(startIndex + i), values[i]);
+        }
+    }
+
+    /**
+     * @method getAll
+     * @description Retrieves a range of Address values.
+     * @param {u32} startIndex - The start index.
+     * @param {u32} count - The number of items to get.
+     * @returns {Address[]} - The requested Address values.
+     */
+    @inline
+    public getAll(startIndex: u32, count: u32): Address[] {
+        assert(startIndex + count <= this._length, '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));
+        }
+        return result;
+    }
+
+    /**
+     * @method toString
+     * @description Returns a string representation of the array.
+     * @returns {string} - A string of the form "[addr0, addr1, ...]".
+     */
+    @inline
+    public toString(): string {
+        let str = '[';
+        for (let i: u32 = 0; i < this._length; i++) {
+            const value = this.get(<u64>i);
+            str += value.toString();
+            if (i !== this._length - 1) {
+                str += ', ';
+            }
+        }
+        str += ']';
+        return str;
+    }
+
+    /**
+     * @method toBytes
+     * @description Returns the packed Address values as a byte array.
+     * @returns {u8[]} - The packed byte array.
+     */
+    @inline
+    public toBytes(): u8[] {
+        const bytes: u8[] = new Array<u8>();
+        for (let i: u32 = 0; i < this._length; i++) {
+            this.ensureValues(i);
+            const value = this._values.get(i);
+            if (value) {
+                const valueBytes = value; // Address is assumed to be or contain a Uint8Array
+                for (let j: u32 = 0; j < valueBytes.length; j++) {
+                    bytes.push(valueBytes[j]);
+                }
+            }
+        }
+        return bytes;
+    }
+
+    /**
+     * @method reset
+     * @description Resets the array by clearing all elements and resetting length and startIndex to zero.
+     */
+    @inline
+    public reset(): void {
+        this._length = 0;
+        this._startIndex = 0;
+        this._isChangedLength = true;
+        this._isChangedStartIndex = true;
+        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, 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
+     * @description Loads and caches the Address from the specified storage slot if not already loaded.
+     * @param {u32} slotIndex - The index of the storage slot.
+     */
+    private ensureValues(slotIndex: u32): void {
+        if (!this._isLoaded.has(slotIndex)) {
+            const storagePointer = this.calculateStoragePointer(slotIndex);
+            const storedU256: u256 = Blockchain.getStorageAt(storagePointer, u256.Zero);
+            const storedAddress: Address =
+                storedU256 == u256.Zero ? this.defaultValue : new Address(storedU256.toBytes());
+            this._values.set(slotIndex, storedAddress);
+            this._isLoaded.add(slotIndex);
+        }
+    }
+
+    /**
+     * @private
+     * @method calculateStoragePointer
+     * @description Calculates the storage pointer for a given slot index.
+     * @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
+        // Slot 0: baseU256Pointer + 1
+        // Slot 1: baseU256Pointer + 2, etc.
+        return SafeMath.add(this.baseU256Pointer, u256.fromU64(slotIndex + 1));
+    }
+}

package/runtime/storage/StoredBoolean.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Blockchain } from '../env';
 
 @final

package/runtime/storage/StoredBooleanArray.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Blockchain } from '../env';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { SafeMath } from '../types/SafeMath';

package/runtime/storage/StoredString.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Blockchain } from '../env';
 import { SafeMath } from '../types/SafeMath';
 import { encodePointer } from '../math/abi';

package/runtime/storage/StoredU128Array.ts

@@ -1,4 +1,4 @@
-import { u128, u256 } from 'as-bignum/assembly';
+import { u128, u256 } from '@btc-vision/as-bignum/assembly';
 import { Blockchain } from '../env';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { SafeMath } from '../types/SafeMath';
@@ -110,9 +110,8 @@ export class StoredU128Array {
         }
 
         const newIndex: u64 = this._length;
-        const effectiveIndex: u64 = this._startIndex + newIndex;
         const wrappedIndex: u64 =
-            effectiveIndex < this.MAX_LENGTH ? effectiveIndex : effectiveIndex % this.MAX_LENGTH;
+            newIndex < this.MAX_LENGTH ? newIndex : newIndex % this.MAX_LENGTH;
         const slotIndex: u32 = <u32>(wrappedIndex / 2);
         const subIndex: u8 = <u8>(wrappedIndex % 2);
 

package/runtime/storage/StoredU16Array.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Blockchain } from '../env';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { SafeMath } from '../types/SafeMath';
@@ -106,9 +106,9 @@ export class StoredU16Array {
         }
 
         const newIndex: u64 = this._length;
-        const effectiveIndex: u64 = this._startIndex + newIndex;
         const wrappedIndex: u64 =
-            effectiveIndex < this.MAX_LENGTH ? effectiveIndex : effectiveIndex % this.MAX_LENGTH;
+            newIndex < this.MAX_LENGTH ? newIndex : newIndex % this.MAX_LENGTH;
+        
         const slotIndex: u64 = wrappedIndex / 16;
         const subIndex: u8 = <u8>(wrappedIndex % 16);
 

package/runtime/storage/StoredU256.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { SafeMath } from '../types/SafeMath';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { Blockchain } from '../env';

package/runtime/storage/StoredU256Array.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Blockchain } from '../env';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { SafeMath } from '../types/SafeMath';
@@ -103,9 +103,8 @@ export class StoredU256Array {
         }
 
         const newIndex: u64 = this._length;
-        const effectiveIndex: u64 = this._startIndex + newIndex;
         const wrappedIndex: u64 =
-            effectiveIndex < this.MAX_LENGTH ? effectiveIndex : effectiveIndex % this.MAX_LENGTH;
+            newIndex < this.MAX_LENGTH ? newIndex : newIndex % this.MAX_LENGTH;
         const slotIndex: u32 = <u32>wrappedIndex;
 
         // Ensure the slot is loaded

package/runtime/storage/StoredU64.ts

@@ -2,7 +2,7 @@ import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 
 /**
  * @class StoredU64

package/runtime/tests/tests.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { Box } from '../utils/box';

package/runtime/types/SafeMath.ts

@@ -1,4 +1,4 @@
-import { u128, u256 } from 'as-bignum/assembly';
+import { u128, u256 } from '@btc-vision/as-bignum/assembly';
 
 export class SafeMath {
     public static ZERO: u256 = u256.fromU32(0);
@@ -267,17 +267,7 @@ export class SafeMath {
         const bitShift = shift % bitsPerSegment;
 
         const segments = [value.lo1, value.lo2, value.hi1, value.hi2];
-
-        const result = new Array<u64>(4).fill(0);
-
-        for (let i = 0; i < segments.length; i++) {
-            if (i + segmentShift < segments.length) {
-                result[i + segmentShift] |= segments[i] << bitShift;
-            }
-            if (bitShift != 0 && i + segmentShift + 1 < segments.length) {
-                result[i + segmentShift + 1] |= segments[i] >>> (bitsPerSegment - bitShift);
-            }
-        }
+        const result = SafeMath.shlSegment(segments, segmentShift, bitShift, bitsPerSegment, 4);
 
         return new u256(result[0], result[1], result[2], result[3]);
     }
@@ -302,17 +292,7 @@ export class SafeMath {
         const bitShift = shift % bitsPerSegment;
 
         const segments = [value.lo, value.hi];
-
-        const result = new Array<u64>(2).fill(0);
-
-        for (let i = 0; i < segments.length; i++) {
-            if (i + segmentShift < segments.length) {
-                result[i + segmentShift] |= segments[i] << bitShift;
-            }
-            if (bitShift != 0 && i + segmentShift + 1 < segments.length) {
-                result[i + segmentShift + 1] |= segments[i] >>> (bitsPerSegment - bitShift);
-            }
-        }
+        const result = SafeMath.shlSegment(segments, segmentShift, bitShift, bitsPerSegment, 2);
 
         return new u128(result[0], result[1]);
     }
@@ -329,8 +309,58 @@ export class SafeMath {
         return u256.xor(a, b);
     }
 
-    public static shr(a: u256, b: u32): u256 {
-        return u256.shr(a, b);
+    public static shr(a: u256, shift: i32): u256 {
+        shift &= 255;
+        if (shift == 0) return a;
+
+        const w = shift >>> 6; // how many full 64-bit words to drop
+        const b = shift & 63; // how many bits to shift within a word
+
+        // Extract the words
+        let lo1 = a.lo1;
+        let lo2 = a.lo2;
+        let hi1 = a.hi1;
+        let hi2 = a.hi2;
+
+        // Shift words down by w words
+        // For w = 1, move lo2->lo1, hi1->lo2, hi2->hi1, and hi2 = 0
+        // For w = 2, move hi1->lo1, hi2->lo2, and zeros in hi1, hi2
+        // For w = 3, move hi2->lo1 and zeros in others
+        // For w >= 4, everything is zero.
+        if (w >= 4) {
+            // Shifting by >= 256 bits zeros out everything
+            return u256.Zero;
+        } else if (w == 3) {
+            lo1 = hi2;
+            lo2 = 0;
+            hi1 = 0;
+            hi2 = 0;
+        } else if (w == 2) {
+            lo1 = hi1;
+            lo2 = hi2;
+            hi1 = 0;
+            hi2 = 0;
+        } else if (w == 1) {
+            lo1 = lo2;
+            lo2 = hi1;
+            hi1 = hi2;
+            hi2 = 0;
+        }
+
+        // Now apply the bit shift b
+        if (b > 0) {
+            // Bring down bits from the higher word
+            const carryLo2 = hi1 << (64 - b);
+            const carryLo1 = lo2 << (64 - b);
+            const carryHi1 = hi2 << (64 - b);
+
+            lo1 = (lo1 >>> b) | carryLo1;
+            lo2 = (lo2 >>> b) | carryLo2;
+            hi1 = (hi1 >>> b) | carryHi1;
+            hi2 = hi2 >>> b;
+        }
+
+        return new u256(lo1, lo2, hi1, hi2);
     }
 
     /**
@@ -360,4 +390,25 @@ export class SafeMath {
 
         return n;
     }
+
+    private static shlSegment(
+        segments: u64[],
+        segmentShift: i32,
+        bitShift: i32,
+        bitsPerSegment: i32,
+        fillCount: u8,
+    ): u64[] {
+        const result = new Array<u64>(fillCount).fill(0);
+
+        for (let i = 0; i < segments.length; i++) {
+            if (i + segmentShift < segments.length) {
+                result[i + segmentShift] |= segments[i] << bitShift;
+            }
+            if (bitShift != 0 && i + segmentShift + 1 < segments.length) {
+                result[i + segmentShift + 1] |= segments[i] >>> (bitsPerSegment - bitShift);
+            }
+        }
+
+        return result;
+    }
 }

package/runtime/types/index.ts

@@ -1,7 +1,7 @@
 import { Map } from '../generic/Map';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { MemorySlotData } from '../memory/MemorySlot';
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesReader } from '../buffer/BytesReader';
 
 export type PointerStorage = Map<MemorySlotPointer, MemorySlotData<u256>>;

package/runtime/utils/encodings.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 
 import { b32decode as _b32decode, bech32m as _bech32m, fromWords, toWords } from './b32';