@btc-vision/btc-runtime 1.5.3 → 1.5.6

package/package.json

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

package/runtime/env/BlockchainEnvironment.ts

@@ -148,6 +148,7 @@ export class BlockchainEnvironment {
         const blockHash = reader.readBytes(32);
         const blockNumber = reader.readU64();
         const blockMedianTime = reader.readU64();
+        const txId = reader.readBytes(32);
         const txHash = reader.readBytes(32);
         const contractAddress = reader.readAddress();
         const contractDeployer = reader.readAddress();
@@ -157,6 +158,7 @@ export class BlockchainEnvironment {
         this._tx = new Transaction(
             caller,
             origin,
+            txId,
             txHash,
         );
 

package/runtime/env/classes/Transaction.ts

@@ -9,6 +9,7 @@ export class Transaction {
     public constructor(
         public readonly sender: Address, // "immediate caller"
         public readonly origin: Address, // "leftmost thing in the call chain"
+        public readonly txId: Uint8Array,
         public readonly hash: Uint8Array,
     ) {
     }

package/runtime/exports/index.ts

@@ -5,7 +5,7 @@ import { Selector } from '../math/abi';
 import { Calldata } from '../types';
 import { env_exit, getCalldata, getEnvironmentVariables } from '../env/global';
 
-const ENVIRONMENT_VARIABLES_BYTE_LENGTH: u32 = 208;
+const ENVIRONMENT_VARIABLES_BYTE_LENGTH: u32 = 240;
 
 export function execute(calldataLength: u32): u32 {
     const environmentVariablesBuffer = new ArrayBuffer(ENVIRONMENT_VARIABLES_BYTE_LENGTH);

package/runtime/math/bytes.ts

@@ -171,23 +171,7 @@ export function encodeBasePointer(pointer: u16, subPointer: Uint8Array): Uint8Ar
 
 @inline
 export function bigEndianAdd(base: Uint8Array, increment: u64): Uint8Array {
-    const out = new Uint8Array(32);
+    const add = u64ToBE32Bytes(increment);
 
-    // Copy the base pointer
-    for (let i = 0; i < 32; i++) {
-        out[i] = base[i];
-    }
-
-    // If this is truly big-endian, out[0] is the MSB, out[31] is the LSB.
-    // So to add `increment`, we start from out[31] backward.
-    let carry: u64 = increment;
-    for (let i = 31; i >= 0; i--) {
-        const sum = <u64>out[i] + (carry & 0xFF);
-        out[i] = <u8>(sum & 0xFF);
-        carry = sum >> 8;
-        if (carry == 0 || i == 0) {
-            break;
-        }
-    }
-    return out;
+    return addUint8ArraysBE(base, add);
 }

package/runtime/storage/arrays/StoredAddressArray.ts

@@ -1,7 +1,12 @@
-import { BytesReader } from '../../buffer/BytesReader';
 import { BytesWriter } from '../../buffer/BytesWriter';
 import { Blockchain } from '../../env';
-import { addUint8ArraysBE, u64ToBE32Bytes } from '../../math/bytes';
+import {
+    addUint8ArraysBE,
+    bigEndianAdd,
+    encodeBasePointer,
+    readLengthAndStartIndex,
+    u64ToBE32Bytes,
+} from '../../math/bytes';
 import { Address } from '../../types/Address';
 import { Revert } from '../../types/Revert';
 
@@ -38,34 +43,32 @@ export class StoredAddressArray {
             `You must pass a 30 bytes sub-pointer. (AddressArray, got ${subPointer.length})`,
         );
 
-        // Construct base pointer as a 32-byte array
-        const writer = new BytesWriter(32);
-        writer.writeU16(pointer);
-        writer.writeBytes(subPointer);
+        const basePointer = encodeBasePointer(pointer, subPointer);
+        this.lengthPointer = Uint8Array.wrap(basePointer.buffer);
+        this.baseU256Pointer = bigEndianAdd(basePointer, 1);
 
-        // We'll reuse the same bytes as the "base pointer" for offsets
-        const baseU256Pointer = writer.getBuffer(); // 32 bytes
-        // For length+startIndex, we'll use the same pointer
-        const lengthPointer = Uint8Array.wrap(baseU256Pointer.buffer);
+        const storedLenStart = Blockchain.getStorageAt(basePointer);
+        const data = readLengthAndStartIndex(storedLenStart);
 
-        // Load length + startIndex from storage (16 bytes: 8 for length, 8 for startIndex).
-        const storedLengthAndStartIndex: Uint8Array = Blockchain.getStorageAt(lengthPointer);
-
-        const reader = new BytesReader(storedLengthAndStartIndex);
-        this._length = reader.readU64();
-        this._startIndex = reader.readU64();
+        this._length = data[0];
+        this._startIndex = data[1];
+    }
 
-        this.lengthPointer = lengthPointer;
-        this.baseU256Pointer = baseU256Pointer;
+    @inline
+    public has(index: u64): bool {
+        return index < this._length;
     }
 
     /** Get an element by its global index. */
     @inline
+    @operator('[]')
     public get(index: u64): Address {
-        if (index > this.MAX_LENGTH) {
-            throw new Revert('Operation failed: Index exceeds maximum allowed value.');
+        if (index >= this._length) {
+            throw new Revert('get: index out of range (address array)');
         }
-        const slotIndex: u32 = <u32>index;
+
+        const physicalIndex = (this._startIndex + index) % this.MAX_LENGTH;
+        const slotIndex: u32 = <u32>physicalIndex;
         this.ensureValues(slotIndex);
 
         return this._values.get(slotIndex);
@@ -73,11 +76,14 @@ export class StoredAddressArray {
 
     /** Set an element by its global index. */
     @inline
+    @operator('[]=')
     public set(index: u64, value: Address): void {
-        if (index > this.MAX_LENGTH) {
-            throw new Revert('Set failed: Index exceeds maximum allowed value.');
+        if (index >= this._length) {
+            throw new Revert('set: index out of range (address array)');
         }
-        const slotIndex: u32 = <u32>index;
+
+        const physicalIndex = (this._startIndex + index) % this.MAX_LENGTH;
+        const slotIndex: u32 = <u32>physicalIndex;
         this.ensureValues(slotIndex);
 
         const currentValue = this._values.get(slotIndex);
@@ -87,33 +93,16 @@ export class StoredAddressArray {
         }
     }
 
-    /** Find the first index containing `value`. Returns -1 if not found. */
-    @inline
-    public indexOf(value: Address): i64 {
-        for (let i: u64 = 0; i < this._length; i++) {
-            if (this.get(i) == value) {
-                return i64(i);
-            }
-        }
-        return -1;
-    }
-
-    /** Check if the array contains `value`. */
-    @inline
-    public contains(value: Address): boolean {
-        return this.indexOf(value) !== -1;
-    }
-
     /** Append an address at the end of the array. */
+    @inline
     public push(value: Address): void {
         if (this._length >= this.MAX_LENGTH) {
-            throw new Revert('Push failed: Array has reached its maximum length.');
+            throw new Revert('push: array reached maximum length (address array)');
         }
 
-        const newIndex: u64 = this._length;
-        const wrappedIndex: u64 =
-            newIndex < this.MAX_LENGTH ? newIndex : newIndex % this.MAX_LENGTH;
-        const slotIndex: u32 = <u32>wrappedIndex;
+        const newLogicalIndex: u64 = this._length;
+        const physicalIndex: u64 = (this._startIndex + newLogicalIndex) % this.MAX_LENGTH;
+        const slotIndex: u32 = <u32>physicalIndex;
 
         this.ensureValues(slotIndex);
         this._values.set(slotIndex, value);
@@ -126,11 +115,12 @@ export class StoredAddressArray {
     /** Delete the last element. */
     public deleteLast(): void {
         if (this._length === 0) {
-            throw new Revert('Delete failed: Array is empty.');
+            throw new Revert('deleteLast: array is empty (address array)');
         }
 
-        const lastIndex: u64 = this._length - 1;
-        const slotIndex: u32 = <u32>(this._startIndex + lastIndex);
+        const lastLogicalIndex: u64 = this._length - 1;
+        const physicalIndex: u64 = (this._startIndex + lastLogicalIndex) % this.MAX_LENGTH;
+        const slotIndex: u32 = <u32>physicalIndex;
         this.ensureValues(slotIndex);
 
         const currentValue = this._values.get(slotIndex);
@@ -150,12 +140,14 @@ export class StoredAddressArray {
     }
 
     /** Delete a specific element by setting it to `defaultValue`. */
+    @inline
     public delete(index: u64): void {
         if (index > this.MAX_LENGTH) {
-            throw new Revert('Operation failed: Index exceeds maximum allowed value.');
+            throw new Revert('delete: index out of range (address array)');
         }
 
-        const slotIndex: u32 = <u32>index;
+        const physicalIndex: u64 = (this._startIndex + index) % this.MAX_LENGTH;
+        const slotIndex: u32 = <u32>physicalIndex;
         this.ensureValues(slotIndex);
 
         const currentValue = this._values.get(slotIndex);
@@ -170,6 +162,7 @@ export class StoredAddressArray {
      *  - Store any changed slotIndex -> Address
      *  - Store updated length and startIndex if changed
      */
+    @inline
     public save(): void {
         // 1) Save changed slots
         const changed = this._isChanged.values();
@@ -196,7 +189,6 @@ export class StoredAddressArray {
 
     /** Clear entire array content from storage, reset 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];
@@ -204,14 +196,13 @@ export class StoredAddressArray {
             Blockchain.setStorageAt(storagePointer, this.defaultValue);
         }
 
-        // Reset length and startIndex in storage
-        Blockchain.setStorageAt(this.lengthPointer, new Uint8Array(0)); // or a 16-byte zero array if preferred
+        Blockchain.setStorageAt(this.lengthPointer, new Uint8Array(32));
+
         this._length = 0;
         this._startIndex = 0;
         this._isChangedLength = false;
         this._isChangedStartIndex = false;
 
-        // Clear internal caches
         this._values.clear();
         this._isChanged.clear();
     }
@@ -228,7 +219,7 @@ export class StoredAddressArray {
     @inline
     public getAll(startIndex: u32, count: u32): Address[] {
         if (startIndex + count > this._length) {
-            throw new Revert('Requested range exceeds array length');
+            throw new Revert('getAll: index out of range (address array)');
         }
 
         const result = new Array<Address>(count);
@@ -260,6 +251,10 @@ export class StoredAddressArray {
         this._startIndex = 0;
         this._isChangedLength = true;
         this._isChangedStartIndex = true;
+
+        this._values.clear();
+        this._isChanged.clear();
+
         this.save();
     }
 
@@ -295,8 +290,8 @@ export class StoredAddressArray {
      * Compute a 32-byte storage pointer = basePointer + (slotIndex + 1) big-endian.
      */
     private calculateStoragePointer(slotIndex: u64): Uint8Array {
-        // Convert (slotIndex + 1) to a 32-byte big-endian offset
-        const offset = u64ToBE32Bytes(slotIndex + 1);
+        // Convert (slotIndex) to a 32-byte big-endian offset
+        const offset = u64ToBE32Bytes(slotIndex);
 
         return addUint8ArraysBE(this.baseU256Pointer, offset);
     }

package/runtime/storage/arrays/StoredBooleanArray.ts

@@ -1,8 +1,16 @@
 import { BytesWriter } from '../../buffer/BytesWriter';
-import { BytesReader } from '../../buffer/BytesReader';
 import { Blockchain } from '../../env';
 import { Revert } from '../../types/Revert';
-import { addUint8ArraysBE, GET_EMPTY_BUFFER, getBit, setBit, u64ToBE32Bytes } from '../../math/bytes';
+import {
+    addUint8ArraysBE,
+    bigEndianAdd,
+    encodeBasePointer,
+    GET_EMPTY_BUFFER,
+    getBit,
+    readLengthAndStartIndex,
+    setBit,
+    u64ToBE32Bytes,
+} from '../../math/bytes';
 
 /**
  * @class StoredBooleanArray
@@ -42,36 +50,41 @@ export class StoredBooleanArray {
     ) {
         assert(subPtr.length <= 30, `You must pass a 30 bytes sub-pointer. (StoredBooleanArray, got ${subPtr.length})`);
 
-        const writer = new BytesWriter(32);
-        writer.writeU16(pointer);
-        writer.writeBytes(subPtr);
-
-        const basePtr = writer.getBuffer();
-
-        this.basePointer = basePtr;
-        this.lengthPointer = basePtr;
+        const basePointer = encodeBasePointer(pointer, subPtr);
+        this.lengthPointer = Uint8Array.wrap(basePointer.buffer);
+        this.basePointer = bigEndianAdd(basePointer, 1);
 
-        const storedLenStart: Uint8Array = Blockchain.getStorageAt(
-            this.lengthPointer,
-        );
+        const storedLenStart = Blockchain.getStorageAt(basePointer);
+        const data = readLengthAndStartIndex(storedLenStart);
 
-        const r = new BytesReader(storedLenStart);
-        this._length = r.readU64();
-        this._startIndex = r.readU64();
+        this._length = data[0];
+        this._startIndex = data[1];
     }
 
     // -------------- Public Accessors -------------- //
 
+    @inline
+    public has(index: u64): bool {
+        return index < this._length;
+    }
+
     /**
      * Retrieve boolean at `index`.
      */
+    @operator('[]')
     @inline
     public get(index: u64): bool {
-        if (index > this.MAX_LENGTH) {
-            throw new Revert('get: Index exceeds maximum allowed value.');
+        if (index >= this._length) {
+            throw new Revert(`get: index out of range (${index} >= ${this._length}, boolean array)`);
         }
-        const slotIndex = index / 256;      // which 32-byte slot
-        const bitIndex = <u16>(index % 256);
+
+        const effectiveIndex = this._startIndex + index;
+        const wrappedIndex = effectiveIndex < this.MAX_LENGTH
+            ? effectiveIndex
+            : effectiveIndex % this.MAX_LENGTH;
+
+        const slotIndex = wrappedIndex / 256;
+        const bitIndex = <u16>(wrappedIndex % 256);
 
         this.ensureSlotLoaded(slotIndex);
 
@@ -82,13 +95,20 @@ export class StoredBooleanArray {
     /**
      * Set boolean at `index`.
      */
+    @operator('[]=')
     @inline
     public set(index: u64, value: bool): void {
-        if (index > this.MAX_LENGTH) {
-            throw new Revert('set: Index exceeds maximum allowed value.');
+        if (index >= this._length) {
+            throw new Revert(`set: index out of range (${index} >= ${this._length}, boolean array)`);
         }
-        const slotIndex = index / 256;
-        const bitIndex = <u16>(index % 256);
+
+        const effectiveIndex = this._startIndex + index;
+        const wrappedIndex = effectiveIndex < this.MAX_LENGTH
+            ? effectiveIndex
+            : effectiveIndex % this.MAX_LENGTH;
+
+        const slotIndex = wrappedIndex / 256;
+        const bitIndex = <u16>(wrappedIndex % 256);
 
         this.ensureSlotLoaded(slotIndex);
 
@@ -108,7 +128,7 @@ export class StoredBooleanArray {
     @inline
     public push(value: bool): void {
         if (this._length >= this.MAX_LENGTH) {
-            throw new Revert('push: Reached max allowed length');
+            throw new Revert('push: reached max allowed length (boolean array)');
         }
 
         const newIndex = this._length;
@@ -137,11 +157,17 @@ export class StoredBooleanArray {
      */
     @inline
     public delete(index: u64): void {
-        if (index > this.MAX_LENGTH) {
-            throw new Revert('delete: Index exceeds maximum allowed value.');
+        if (index >= this._length) {
+            throw new Revert('delete: index out of range (boolean array)');
         }
-        const slotIndex = index / 256;
-        const bitIndex = <u16>(index % 256);
+
+        const effectiveIndex = this._startIndex + index;
+        const wrappedIndex = effectiveIndex < this.MAX_LENGTH
+            ? effectiveIndex
+            : effectiveIndex % this.MAX_LENGTH;
+
+        const slotIndex = wrappedIndex / 256;
+        const bitIndex = <u16>(wrappedIndex % 256);
 
         this.ensureSlotLoaded(slotIndex);
 
@@ -161,8 +187,9 @@ export class StoredBooleanArray {
     @inline
     public deleteLast(): void {
         if (this._length === 0) {
-            throw new Revert('deleteLast: Array is empty');
+            throw new Revert('deleteLast: array is empty');
         }
+
         const lastIndex = this._length - 1;
         this.delete(lastIndex);
 
@@ -187,12 +214,11 @@ export class StoredBooleanArray {
 
         // 2) If length or startIndex changed, store them
         if (this._isChangedLength || this._isChangedStartIndex) {
-            const w = new BytesWriter(16);
+            const w = new BytesWriter(32);
             w.writeU64(this._length);
             w.writeU64(this._startIndex);
 
-            const data = w.getBuffer(); // 16 bytes
-            // You could store 32 bytes if you prefer; the leftover bytes can be 0
+            const data = w.getBuffer();
             Blockchain.setStorageAt(this.lengthPointer, data);
 
             this._isChangedLength = false;
@@ -201,11 +227,10 @@ export class StoredBooleanArray {
     }
 
     /**
-     * Delete all slots in storage (that are loaded) + reset length + startIndex.
+     * Delete all slots in storage (that are loaded) + reset length + _startIndex.
      */
     @inline
     public deleteAll(): void {
-        // clear all loaded slots
         const keys = this._values.keys();
         const zeroArr = GET_EMPTY_BUFFER();
         for (let i = 0; i < keys.length; i++) {
@@ -214,17 +239,14 @@ export class StoredBooleanArray {
             Blockchain.setStorageAt(storagePointer, zeroArr);
         }
 
-        // also reset length + startIndex in storage
-        const writer = new BytesWriter(16);
-        writer.writeU64(0);
-        writer.writeU64(0);
+        const writer = new BytesWriter(32);
         Blockchain.setStorageAt(this.lengthPointer, writer.getBuffer());
 
-        // reset in memory
         this._length = 0;
         this._startIndex = 0;
         this._isChangedLength = false;
         this._isChangedStartIndex = false;
+
         this._values.clear();
         this._isChanged.clear();
     }
@@ -243,18 +265,20 @@ export class StoredBooleanArray {
      * Retrieve a batch of bools.
      */
     @inline
-    public getAll(startIndex: u64, count: u64): bool[] {
-        if (startIndex + count > this._length) {
-            throw new Revert('getAll: range exceeds array length');
+    public getAll(start: u64, count: u64): bool[] {
+        if (start + count > this._length) {
+            throw new Revert('getAll: range exceeds array length (boolean array)');
         }
+
         if (count > u64(u32.MAX_VALUE)) {
-            throw new Revert('getAll: range exceeds max allowed');
+            throw new Revert('getAll: range exceeds max allowed (boolean array)');
         }
 
         const result = new Array<bool>(<i32>count);
         for (let i: u64 = 0; i < count; i++) {
-            result[<i32>i] = this.get(startIndex + i);
+            result[<i32>i] = this.get(start + i);
         }
+
         return result;
     }
 
@@ -298,6 +322,12 @@ export class StoredBooleanArray {
         return this._length;
     }
 
+    @inline
+    public setStartingIndex(index: u64): void {
+        this._startIndex = index;
+        this._isChangedStartIndex = true;
+    }
+
     /**
      * Current starting index for the array.
      */
@@ -306,7 +336,6 @@ export class StoredBooleanArray {
         return this._startIndex;
     }
 
-
     /**
      * Ensure the 32-byte slot for `slotIndex` is loaded into _values.
      */
@@ -322,7 +351,7 @@ export class StoredBooleanArray {
      * Convert `slotIndex` -> pointer = basePointer + (slotIndex + 1), as big-endian addition.
      */
     private calculateStoragePointer(slotIndex: u64): Uint8Array {
-        const offset = u64ToBE32Bytes(slotIndex + 1);
+        const offset = u64ToBE32Bytes(slotIndex);
         return addUint8ArraysBE(this.basePointer, offset);
     }
 }

package/runtime/storage/arrays/StoredPackedArray.ts

@@ -1,4 +1,5 @@
 import {
+    bigEndianAdd,
     encodeBasePointer,
     GET_EMPTY_BUFFER,
     readLengthAndStartIndex,
@@ -53,7 +54,7 @@ export abstract class StoredPackedArray<T> {
 
         const basePointer = encodeBasePointer(pointer, subPointer);
         this.lengthPointer = Uint8Array.wrap(basePointer.buffer);
-        this.basePointer = basePointer;
+        this.basePointer = bigEndianAdd(basePointer, 1);
 
         const storedLenStart = Blockchain.getStorageAt(basePointer);
         const data = readLengthAndStartIndex(storedLenStart);
@@ -62,9 +63,11 @@ export abstract class StoredPackedArray<T> {
         this._startIndex = data[1];
     }
 
+    @inline
+    @operator('[]')
     public get(index: u64): T {
         if (index > this.MAX_LENGTH) {
-            throw new Revert('get: index exceeds MAX_LENGTH');
+            throw new Revert('get: index exceeds MAX_LENGTH (packed array)');
         }
 
         const cap = this.getSlotCapacity();
@@ -79,7 +82,13 @@ export abstract class StoredPackedArray<T> {
         return arr[subIndex];
     }
 
+    @inline
+    @operator('[]=')
     public set(index: u64, value: T): void {
+        if (index > this.MAX_LENGTH) {
+            throw new Revert('set: index exceeds MAX_LENGTH (packed array)');
+        }
+
         const cap = this.getSlotCapacity();
         const slotIndex = index / cap;
         const subIndex = <u32>(index % cap);
@@ -95,9 +104,10 @@ export abstract class StoredPackedArray<T> {
         }
     }
 
+    @inline
     public push(value: T): void {
         if (this._length >= this.MAX_LENGTH) {
-            throw new Revert('push: array has reached MAX_LENGTH');
+            throw new Revert('push: array has reached MAX_LENGTH (packed array)');
         }
 
         const newIndex = this._length;
@@ -123,6 +133,7 @@ export abstract class StoredPackedArray<T> {
      * "Delete" by zeroing out the element at `index`,
      * but does not reduce the length.
      */
+    @inline
     public delete(index: u64): void {
         const cap = this.getSlotCapacity();
         const slotIndex = index / cap;
@@ -143,9 +154,10 @@ export abstract class StoredPackedArray<T> {
     /**
      * Remove the last element by zeroing it and decrementing length by 1.
      */
+    @inline
     public deleteLast(): void {
         if (this._length == 0) {
-            throw new Revert('deleteLast: array is empty');
+            throw new Revert('deleteLast: array is empty (packed array)');
         }
 
         const lastIndex = this._length - 1;
@@ -155,11 +167,13 @@ export abstract class StoredPackedArray<T> {
         this._isChangedLength = true;
     }
 
+    @inline
     public setMultiple(startIndex: u64, values: T[]): void {
         const end = startIndex + <u64>values.length;
         if (end > this._length) {
-            throw new Revert('setMultiple: out of range');
+            throw new Revert('setMultiple: out of range (packed array)');
         }
+
         for (let i = 0; i < values.length; i++) {
             this.set(startIndex + <u64>i, values[i]);
         }
@@ -168,10 +182,10 @@ export abstract class StoredPackedArray<T> {
     // -----------------------------------------------------------
     //              Public Array-Like Methods
     // -----------------------------------------------------------
-
+    @inline
     public getAll(startIndex: u64, count: u64): T[] {
         if (count > <u64>u32.MAX_VALUE) {
-            throw new Revert('getAll: count too large');
+            throw new Revert('getAll: count too large (packed array)');
         }
 
         const out = new Array<T>(<i32>count);
@@ -182,14 +196,17 @@ export abstract class StoredPackedArray<T> {
         return out;
     }
 
+    @inline
     public getLength(): u64 {
         return this._length;
     }
 
+    @inline
     public startingIndex(): u64 {
         return this._startIndex;
     }
 
+    @inline
     public setStartingIndex(index: u64): void {
         this._startIndex = index;
         this._isChangedStartIndex = true;
@@ -250,6 +267,9 @@ export abstract class StoredPackedArray<T> {
         this._isChanged.clear();
     }
 
+    /**
+     * Reset the array to its initial state.
+     */
     public reset(): void {
         this._length = 0;
         this._startIndex = 0;

package/runtime/storage/arrays/StoredU128Array.ts

@@ -59,6 +59,6 @@ export class StoredU128Array extends StoredPackedArray<u128> {
     }
 
     protected calculateStoragePointer(slotIndex: u64): Uint8Array {
-        return bigEndianAdd(this.basePointer, slotIndex + 1);
+        return bigEndianAdd(this.basePointer, slotIndex);
     }
 }

package/runtime/storage/arrays/StoredU16Array.ts

@@ -53,6 +53,6 @@ export class StoredU16Array extends StoredPackedArray<u16> {
     }
 
     protected calculateStoragePointer(slotIndex: u64): Uint8Array {
-        return bigEndianAdd(this.basePointer, slotIndex + 1);
+        return bigEndianAdd(this.basePointer, slotIndex);
     }
 }

package/runtime/storage/arrays/StoredU256Array.ts

@@ -34,6 +34,6 @@ export class StoredU256Array extends StoredPackedArray<u256> {
     }
 
     protected calculateStoragePointer(slotIndex: u64): Uint8Array {
-        return bigEndianAdd(this.basePointer, slotIndex + 1);
+        return bigEndianAdd(this.basePointer, slotIndex);
     }
 }

package/runtime/storage/arrays/StoredU32Array.ts

@@ -52,6 +52,6 @@ export class StoredU32Array extends StoredPackedArray<u32> {
     }
 
     protected calculateStoragePointer(slotIndex: u64): Uint8Array {
-        return bigEndianAdd(this.basePointer, slotIndex + 1);
+        return bigEndianAdd(this.basePointer, slotIndex);
     }
 }

package/runtime/storage/arrays/StoredU64Array.ts

@@ -61,6 +61,6 @@ export class StoredU64Array extends StoredPackedArray<u64> {
     }
 
     protected calculateStoragePointer(slotIndex: u64): Uint8Array {
-        return bigEndianAdd(this.basePointer, slotIndex + 1);
+        return bigEndianAdd(this.basePointer, slotIndex);
     }
 }

package/runtime/storage/arrays/StoredU8Array.ts

@@ -43,6 +43,6 @@ export class StoredU8Array extends StoredPackedArray<u8> {
 
     protected calculateStoragePointer(slotIndex: u64): Uint8Array {
         // basePointer + (slotIndex+1) in big-endian
-        return bigEndianAdd(this.basePointer, slotIndex + 1);
+        return bigEndianAdd(this.basePointer, slotIndex);
     }
 }