@btc-vision/btc-runtime 1.10.10 → 1.10.11

package/docs/api-reference/storage.md

@@ -0,0 +1,840 @@
+# Storage API Reference
+
+Storage classes provide persistent state management for OPNet smart contracts.
+
+## Import
+
+```typescript
+import {
+    StoredU256,
+    StoredU64,
+    StoredU32,
+    StoredBoolean,
+    StoredString,
+    StoredAddress,
+    StoredU256Array,
+    StoredAddressArray,
+    AddressMemoryMap,
+    StoredMapU256,
+    Blockchain,
+    EMPTY_POINTER,
+} from '@btc-vision/btc-runtime/runtime';
+```
+
+## CRITICAL: Map Implementation Warning
+
+> **DO NOT USE AssemblyScript's Built-in Map**
+>
+> When creating custom map implementations or extending map functionality, you **MUST** use the Map class from `@btc-vision/btc-runtime/runtime`, NOT the built-in AssemblyScript Map.
+>
+> **Why the AssemblyScript Map is broken for blockchain:**
+> - NOT optimized for blockchain storage patterns
+> - Does NOT handle Uint8Array buffers as keys correctly
+> - Does NOT work properly with Address key comparisons
+> - Will cause silent data corruption or key collisions
+>
+> **CORRECT:**
+> ```typescript
+> import { Map } from '@btc-vision/btc-runtime/runtime';
+>
+> export class MyCustomMap<V> extends Map<Address, V> {
+>     // Your implementation
+> }
+> ```
+>
+> **WRONG:**
+> ```typescript
+> // DO NOT DO THIS - will break!
+> const map = new Map<Uint8Array, u256>();  // AssemblyScript Map
+> ```
+>
+> The btc-runtime Map is specifically designed to:
+> - Handle Address and Uint8Array key comparisons correctly
+> - Optimize for blockchain storage access patterns
+> - Support proper serialization for persistent storage
+> - Prevent key collisions with custom equality logic
+
+## Storage Type Hierarchy
+
+The following diagram shows the complete hierarchy of storage types available in the runtime:
+
+```mermaid
+graph LR
+    A[Storage Types]
+
+    subgraph "Primitive Types"
+        B1[StoredU256<br/>StoredU64<br/>StoredU32]
+        B2[StoredBoolean<br/>StoredString<br/>StoredAddress]
+    end
+
+    subgraph "Array Types"
+        C1[StoredU256Array<br/>StoredU64Array]
+        C2[StoredU32Array<br/>StoredAddressArray]
+        C3[StoredBooleanArray]
+    end
+
+    subgraph "Map Types"
+        D1[AddressMemoryMap<br/>Address -> u256]
+        D2[StoredMapU256<br/>u256 -> u256]
+        D3[MapOfMap<br/>Nested maps]
+    end
+
+    subgraph "Backend Storage"
+        E1[encodePointer<br/>Generate hash]
+        E2[getStorageAt<br/>Read value]
+        E3[setStorageAt<br/>Write value]
+    end
+
+    A --> B1 & B2
+    A --> C1 & C2 & C3
+    A --> D1 & D2 & D3
+
+    B1 & B2 --> E1
+    C1 & C2 & C3 --> E1
+    D1 & D2 & D3 --> E1
+
+    E1 --> E2 & E3
+```
+
+```mermaid
+classDiagram
+    class StoredU256 {
+        -pointer: u16
+        -subPointer: Uint8Array
+        +get value() u256
+        +set value(v: u256)
+    }
+
+    class StoredString {
+        -pointer: u16
+        -index: u64
+        +get value() string
+        +set value(v: string)
+    }
+
+    class AddressMemoryMap {
+        -pointer: u16
+        +get(key: Address) u256
+        +set(key: Address, value: u256)
+        +has(key: Address) bool
+        +delete(key: Address) bool
+    }
+
+    class StoredU256Array {
+        -pointer: u16
+        +getLength() u32
+        +push(value: u256) u32
+        +shift() u256
+        +get(index: u32) u256
+        +set(index: u32, value: u256)
+        +save()
+    }
+
+    class MapOfMap {
+        -pointer: u16
+        +get(key: Address) Nested~u256~
+        +set(key: Address, value: Nested~u256~)
+        +has(key: Address) bool
+        +delete(key: Address) bool
+    }
+
+    class Blockchain {
+        +getStorageAt(hash: Uint8Array) Uint8Array
+        +setStorageAt(hash: Uint8Array, value: Uint8Array)
+        +encodePointer(pointer: u16, subPointer: Uint8Array) Uint8Array
+    }
+
+    StoredU256 ..> Blockchain
+    StoredString ..> Blockchain
+    AddressMemoryMap ..> Blockchain
+    StoredU256Array ..> Blockchain
+    MapOfMap ..> Blockchain
+
+    note for Blockchain "All storage types use\nBlockchain as backend"
+```
+
+## Primitive Storage
+
+### StoredU256
+
+Stores a 256-bit unsigned integer.
+
+```typescript
+class StoredU256 {
+    constructor(pointer: u16, subPointer: Uint8Array)
+    public get value(): u256
+    public set value(v: u256)
+    public get toBytes(): Uint8Array
+    public toString(): string
+    public set(value: u256): this
+    public add(value: u256): this       // operator +
+    public sub(value: u256): this       // operator -
+    public mul(value: u256): this       // operator *
+    public addNoCommit(value: u256): this
+    public subNoCommit(value: u256): this
+    public commit(): this
+    public toUint8Array(): Uint8Array
+}
+```
+
+```typescript
+private balancePointer: u16 = Blockchain.nextPointer;
+private _balance: StoredU256 = new StoredU256(this.balancePointer, EMPTY_POINTER);
+
+// Usage
+this._balance.value = u256.fromU64(1000);
+const balance = this._balance.value;
+```
+
+The following sequence diagram shows how storage read and write operations work:
+
+```mermaid
+sequenceDiagram
+    participant Contract
+    participant Storage as Storage Object
+    participant Encode as encodePointer
+    participant BC as Blockchain
+
+    Note over Contract,BC: Write Operation
+
+    Contract->>Contract: private balance: StoredU256
+    Contract->>Contract: balance.value = u256.fromU64(1000)
+
+    Storage->>Encode: encodePointer(pointer, subPointer)
+    Encode->>Encode: SHA-256(pointer + subPointer)
+    Encode->>Storage: Return 32-byte hash
+
+    Storage->>Storage: value.toUint8Array(true)
+    Storage->>BC: setStorageAt(hash, bytes)
+    BC->>BC: Write to persistent storage
+
+    Note over Contract,BC: Read Operation
+
+    Contract->>Contract: const amount = balance.value
+
+    Storage->>Encode: encodePointer(pointer, subPointer)
+    Encode->>Storage: Return 32-byte hash
+
+    Storage->>BC: getStorageAt(hash)
+    BC->>Storage: Return 32-byte value
+    Storage->>Storage: u256.fromUint8ArrayBE(bytes)
+    Storage->>Contract: Return u256 value
+```
+
+### StoredU64
+
+Stores up to four 64-bit unsigned integers within a single u256 storage slot.
+
+```typescript
+class StoredU64 {
+    constructor(pointer: u16, subPointer: Uint8Array)
+    public get(index: u8): u64        // index 0-3
+    public set(index: u8, value: u64): void
+    public save(): void
+    public getAll(): u64[]
+    public setMultiple(values: u64[]): void
+    public reset(): void
+    public toString(): string
+}
+```
+
+```typescript
+private timestampPointer: u16 = Blockchain.nextPointer;
+private _timestamps: StoredU64 = new StoredU64(this.timestampPointer, EMPTY_POINTER);
+
+// Usage - stores up to 4 u64 values in one storage slot
+this._timestamps.set(0, Blockchain.block.medianTime);  // First u64
+this._timestamps.set(1, someOtherTimestamp);           // Second u64
+this._timestamps.save();                                // Commit to storage
+
+const firstTimestamp = this._timestamps.get(0);
+```
+
+### StoredU32
+
+Stores up to eight 32-bit unsigned integers within a single u256 storage slot.
+
+```typescript
+class StoredU32 {
+    constructor(pointer: u16, subPointer: Uint8Array)
+    public get(index: u8): u32        // index 0-7
+    public set(index: u8, value: u32): void
+    public save(): void
+    public getAll(): u32[]
+    public setMultiple(values: u32[]): void
+    public reset(): void
+    public toString(): string
+}
+```
+
+```typescript
+private configPointer: u16 = Blockchain.nextPointer;
+private _config: StoredU32 = new StoredU32(this.configPointer, EMPTY_POINTER);
+
+// Usage - stores up to 8 u32 values in one storage slot
+this._config.set(0, 100);  // First u32
+this._config.set(1, 200);  // Second u32
+this._config.save();       // Commit to storage
+
+const firstValue = this._config.get(0);
+```
+
+### StoredBoolean
+
+Stores a boolean value.
+
+```typescript
+class StoredBoolean {
+    constructor(pointer: u16, defaultValue: bool)
+    public get value(): bool
+    public set value(v: bool)
+    public toUint8Array(): Uint8Array
+}
+```
+
+```typescript
+private pausedPointer: u16 = Blockchain.nextPointer;
+private _paused: StoredBoolean = new StoredBoolean(this.pausedPointer, false);
+
+// Usage
+this._paused.value = true;
+if (this._paused.value) {
+    throw new Revert('Contract is paused');
+}
+```
+
+### StoredString
+
+Stores a string value.
+
+```typescript
+class StoredString {
+    constructor(pointer: u16, index: u64 = 0)
+    public get value(): string
+    public set value(v: string)
+}
+```
+
+```typescript
+private namePointer: u16 = Blockchain.nextPointer;
+private _name: StoredString = new StoredString(this.namePointer, 0);
+
+// Usage
+this._name.value = 'My Token';
+const name = this._name.value;
+```
+
+### StoredAddress
+
+Stores an Address value. Default value is Address.zero().
+
+```typescript
+class StoredAddress {
+    constructor(pointer: u16)
+    public get value(): Address
+    public set value(v: Address)
+    public isDead(): bool  // Note: checks if address equals Address.zero(), not ExtendedAddress.dead()
+}
+```
+
+```typescript
+private ownerPointer: u16 = Blockchain.nextPointer;
+private _owner: StoredAddress = new StoredAddress(this.ownerPointer);
+
+// Usage
+this._owner.value = Blockchain.tx.origin;
+const owner = this._owner.value;
+```
+
+## Array Storage
+
+### StoredU256Array
+
+Dynamic array of u256 values. Elements are packed into 32-byte storage slots.
+
+```typescript
+class StoredU256Array {
+    constructor(pointer: u16, subPointer: Uint8Array, maxLength: u32 = DEFAULT_MAX_LENGTH)
+    public getLength(): u32
+    public push(value: u256, isPhysical?: bool): u32
+    public deleteLast(): void
+    public delete(index: u32): void
+    public shift(): u256
+    public get(index: u32): u256
+    public set(index: u32, value: u256): void
+    public getAll(startIndex: u32, count: u32): u256[]
+    public setMultiple(startIndex: u32, values: u256[]): void
+    public save(): void
+    public reset(): void
+    public deleteAll(): void
+    public startingIndex(): u32
+    public setStartingIndex(index: u32): void
+}
+```
+
+```typescript
+private tokenIdsPointer: u16 = Blockchain.nextPointer;
+private tokenIds: StoredU256Array = new StoredU256Array(this.tokenIdsPointer, EMPTY_POINTER);
+
+// Usage
+this.tokenIds.push(u256.fromU64(1));
+this.tokenIds.push(u256.fromU64(2));
+this.tokenIds.save();                  // Commit changes to storage
+
+const first = this.tokenIds.get(0);    // u256.fromU64(1)
+const len = this.tokenIds.getLength(); // 2
+```
+
+The following diagram shows the array operation flow:
+
+```mermaid
+flowchart LR
+    A[StoredU256Array] --> B{Operation<br/>Type}
+
+    subgraph "push Operation"
+        B -->|push| C[Get current length]
+        C --> D[Encode pointer<br/>with index]
+        D --> E[Write value at index]
+        E --> F[Increment length]
+    end
+
+    subgraph "get Operation"
+        B -->|get| G[Validate<br/>index < length]
+        G --> H[Encode pointer<br/>with index]
+        H --> I[Read value<br/>from storage]
+        I --> J[Return u256]
+    end
+
+    subgraph "shift Operation"
+        B -->|shift| K[Validate<br/>length > 0]
+        K --> L[Read first element]
+        L --> M[Decrement length]
+        M --> N[Return value]
+    end
+
+    subgraph "set Operation"
+        B -->|set| O[Validate<br/>index < length]
+        O --> P[Encode pointer<br/>with index]
+        P --> Q[Write new value]
+    end
+```
+
+### StoredAddressArray
+
+Dynamic array of Address values. Each address takes one 32-byte storage slot.
+
+```typescript
+class StoredAddressArray {
+    constructor(pointer: u16, subPointer: Uint8Array, maxLength: u32 = DEFAULT_MAX_LENGTH)
+    public getLength(): u32
+    public push(value: Address, isPhysical?: bool): u32
+    public deleteLast(): void
+    public delete(index: u32): void
+    public shift(): Address
+    public get(index: u32): Address
+    public set(index: u32, value: Address): void
+    public getAll(startIndex: u32, count: u32): Address[]
+    public setMultiple(startIndex: u32, values: Address[]): void
+    public save(): void
+    public reset(): void
+    public deleteAll(): void
+    public startingIndex(): u32
+    public setStartingIndex(index: u32): void
+}
+```
+
+```typescript
+private oraclesPointer: u16 = Blockchain.nextPointer;
+private oracles: StoredAddressArray = new StoredAddressArray(this.oraclesPointer, EMPTY_POINTER);
+
+// Add oracle
+this.oracles.push(oracleAddress);
+this.oracles.save();  // Commit changes
+
+// Iterate
+for (let i: u32 = 0; i < this.oracles.getLength(); i++) {
+    const oracle = this.oracles.get(i);
+    // Process oracle
+}
+```
+
+### Other Array Types
+
+All array types share the same base API as `StoredU256Array` (extending `StoredPackedArray<T>`) with their respective element types:
+
+- `StoredU128Array` - 2 u128 values per 32-byte slot
+- `StoredU64Array` - 4 u64 values per 32-byte slot
+- `StoredU32Array` - 8 u32 values per 32-byte slot
+- `StoredU16Array` - 16 u16 values per 32-byte slot
+- `StoredU8Array` - 32 u8 values per 32-byte slot
+- `StoredBooleanArray` - 256 boolean values per 32-byte slot (bit-packed)
+
+> **Note:** These are array types only. There are no standalone `StoredU128`, `StoredU16`, or `StoredU8` primitive classes. For storing single small values, use `StoredU64` (which packs 4 u64 values) or `StoredU32` (which packs 8 u32 values) in a single storage slot.
+
+## Map Storage
+
+### AddressMemoryMap
+
+Maps addresses to u256 values. Always returns u256.Zero for unset addresses.
+
+```typescript
+class AddressMemoryMap {
+    constructor(pointer: u16)
+    public get(key: Address): u256
+    public set(key: Address, value: u256): this
+    public getAsUint8Array(key: Address): Uint8Array
+    public setAsUint8Array(key: Address, value: Uint8Array): this
+    public has(key: Address): bool
+    public delete(key: Address): bool
+}
+```
+
+The following diagram shows how map keys are converted to storage hashes:
+
+```mermaid
+flowchart LR
+    subgraph "Key to Hash"
+        A[AddressMemoryMap] --> B[Address Key]
+        B --> C[encodePointer<br/>pointer, address.toBytes]
+        C --> D[32-byte storage hash]
+    end
+
+    subgraph "Operations"
+        D --> E{get or set?}
+        E -->|get| F[Blockchain.getStorageAt<br/>hash]
+        F --> G[Convert to u256]
+        G --> H[Return value<br/>or u256.Zero]
+        E -->|set| I[value.toUint8Array]
+        I --> J[Blockchain.setStorageAt<br/>hash, bytes]
+    end
+```
+
+#### Usage Example
+
+```typescript
+// mapping(address => uint256)
+private balancesPointer: u16 = Blockchain.nextPointer;
+private balances: AddressMemoryMap;
+
+constructor() {
+    super();
+    this.balances = new AddressMemoryMap(this.balancesPointer);
+}
+
+// Usage
+const balance = this.balances.get(userAddress);  // Returns u256
+this.balances.set(userAddress, u256.fromU64(1000));
+```
+
+The following sequence diagram shows the complete balance mapping flow:
+
+```mermaid
+sequenceDiagram
+    participant Contract
+    participant Map as AddressMemoryMap
+    participant BC as Blockchain
+
+    Note over Contract,BC: Balance Mapping Example
+
+    Contract->>Contract: balances = new AddressMemoryMap(pointer)
+
+    Note over Contract,BC: Set Balance
+
+    Contract->>Map: balances.set(userAddress, u256.fromU64(1000))
+    Map->>Map: hash = encodePointer(pointer, userAddress.toBytes())
+    Map->>BC: setStorageAt(hash, 1000.toUint8Array())
+    BC->>Map: Storage updated
+
+    Note over Contract,BC: Get Balance
+
+    Contract->>Map: balances.get(userAddress)
+    Map->>Map: hash = encodePointer(pointer, userAddress.toBytes())
+    Map->>BC: getStorageAt(hash)
+    BC->>Map: Return bytes
+    Map->>Map: u256.fromUint8ArrayBE(bytes)
+    Map->>Contract: Return u256.fromU64(1000)
+
+    Note over Contract,BC: Get Non-Existent Balance
+
+    Contract->>Map: balances.get(unknownAddress)
+    Map->>BC: getStorageAt(hash)
+    BC->>Map: Return zeros
+    Map->>Contract: Return u256.Zero
+```
+
+### StoredMapU256
+
+Maps u256 keys to u256 values.
+
+```typescript
+class StoredMapU256 {
+    constructor(pointer: u16, subPointer: Uint8Array = new Uint8Array(30))
+    public get(key: u256): u256
+    public set(key: u256, value: u256): void
+    public delete(key: u256): void  // Sets value to zero
+}
+```
+
+Note: `StoredMapU256` does not have a `has()` method. To check if a key exists, compare the returned value with `u256.Zero`.
+
+```typescript
+private dataPointer: u16 = Blockchain.nextPointer;
+private data: StoredMapU256 = new StoredMapU256(this.dataPointer);
+
+// Usage
+const key = u256.fromU64(123);
+this.data.set(key, u256.fromU64(456));
+const value = this.data.get(key);
+```
+
+### Nested Maps (MapOfMap)
+
+For allowances pattern (owner => spender => amount):
+
+```typescript
+class MapOfMap<T> {
+    constructor(pointer: u16)
+    public get(key: Address): Nested<T>
+    public set(key: Address, value: Nested<T>): this
+    public has(key: Address): bool
+    public delete(key: Address): bool
+    public clear(): void
+}
+
+class Nested<T> {
+    constructor(parent: Uint8Array, pointer: u16)
+    public get(key: Uint8Array): T
+    public set(key: Uint8Array, value: T): this
+    public has(key: Uint8Array): bool
+}
+```
+
+```typescript
+import { MapOfMap, Nested } from '@btc-vision/btc-runtime/runtime';
+
+// mapping(address => mapping(address => uint256))
+private allowancesPointer: u16 = Blockchain.nextPointer;
+private allowances: MapOfMap<u256>;
+
+constructor() {
+    super();
+    this.allowances = new MapOfMap<u256>(this.allowancesPointer);
+}
+
+// Get nested value - two-step process
+protected getAllowance(owner: Address, spender: Address): u256 {
+    const ownerMap = this.allowances.get(owner);  // Returns Nested<u256>
+    return ownerMap.get(spender);                  // Returns u256
+}
+
+// Set nested value - get, modify, commit back
+protected setAllowance(owner: Address, spender: Address, amount: u256): void {
+    const ownerMap = this.allowances.get(owner);  // Get the nested map
+    ownerMap.set(spender, amount);                 // Modify it
+    this.allowances.set(owner, ownerMap);          // Commit back
+}
+```
+
+> **Important:** `MapOfMap.get(key)` returns a `Nested<T>` object, not the final value. You must call `.get()` on the nested object to retrieve the actual value.
+
+The following diagram shows the two-level nested storage pattern:
+
+```mermaid
+flowchart LR
+    subgraph "Read Path - Two-Level Mapping"
+        A[MapOfMap allowances] --> B[First Level:<br/>Owner Address]
+        B --> C[allowances.get owner]
+        C --> D[Returns Nested<br/>u256 Map]
+        D --> E[Second Level:<br/>Spender Address]
+        E --> F[nested.get spender]
+        F --> G[Returns u256<br/>allowance]
+    end
+
+    subgraph "Write Path - Set Allowance"
+        H[Set Allowance] --> I[Get owner's<br/>nested map]
+        I --> J[nested.set<br/>spender, amount]
+        J --> K[Commit back<br/>to MapOfMap]
+        K --> L[allowances.set<br/>owner, nested]
+    end
+```
+
+The following sequence diagram shows the nested allowance operations:
+
+```mermaid
+sequenceDiagram
+    participant Contract
+    participant MapOfMap as allowances MapOfMap
+    participant Nested as Nested Map
+    participant BC as Blockchain
+
+    Note over Contract,BC: Get Nested Allowance
+
+    Contract->>MapOfMap: allowances.get(owner)
+    MapOfMap->>MapOfMap: Compute owner's map hash
+    MapOfMap->>Contract: Return Nested~u256~ map
+
+    Contract->>Nested: nested.get(spender)
+    Nested->>Nested: Compute spender hash within owner's space
+    Nested->>BC: getStorageAt(combined_hash)
+    BC->>Nested: Return allowance bytes
+    Nested->>Contract: Return u256 allowance
+
+    Note over Contract,BC: Set Nested Allowance
+
+    Contract->>MapOfMap: allowances.get(owner)
+    MapOfMap->>Contract: Return Nested map
+
+    Contract->>Nested: nested.set(spender, new_amount)
+    Nested->>BC: setStorageAt(combined_hash, new_amount)
+
+    Contract->>MapOfMap: allowances.set(owner, nested)
+    Note over Contract: Commit nested map changes
+```
+
+## Storage Patterns
+
+### Lazy Initialization
+
+```typescript
+private _data: StoredU256 | null = null;
+private dataPointer: u16 = Blockchain.nextPointer;
+
+private get data(): StoredU256 {
+    if (!this._data) {
+        this._data = new StoredU256(this.dataPointer, EMPTY_POINTER);
+    }
+    return this._data;
+}
+```
+
+### Computed Storage Keys
+
+```typescript
+import { encodePointer } from '@btc-vision/btc-runtime/runtime';
+
+private storagePointer: u16 = Blockchain.nextPointer;
+
+private getKey(addr: Address, slot: u256): u256 {
+    const combined = new Uint8Array(64);
+    combined.set(addr.toBytes(), 0);
+    combined.set(slot.toUint8Array(), 32);
+    return u256.fromBytes(Blockchain.sha256(combined));
+}
+
+public getValue(addr: Address, slot: u256): u256 {
+    const key = this.getKey(addr, slot);
+    const pointerHash = encodePointer(this.storagePointer, key.toUint8Array(true));
+    const stored = Blockchain.getStorageAt(pointerHash);
+    return u256.fromUint8ArrayBE(stored);
+}
+```
+
+### Counter Pattern
+
+```typescript
+private counterPointer: u16 = Blockchain.nextPointer;
+private _counter: StoredU256 = new StoredU256(this.counterPointer, EMPTY_POINTER);
+
+public getNextId(): u256 {
+    const current = this._counter.value;
+    this._counter.value = SafeMath.add(current, u256.One);
+    return current;
+}
+```
+
+## Low-Level Storage
+
+Direct storage access via Blockchain:
+
+```typescript
+import { encodePointer } from '@btc-vision/btc-runtime/runtime';
+
+// Generate storage key hash
+public encodePointer(pointer: u16, subPointer: Uint8Array): Uint8Array
+
+// Write to storage
+public setStorageAt(pointerHash: Uint8Array, value: Uint8Array): void
+
+// Read from storage
+public getStorageAt(pointerHash: Uint8Array): Uint8Array
+
+// Check existence
+public hasStorageAt(pointerHash: Uint8Array): bool
+```
+
+```typescript
+// Direct storage example
+const pointer: u16 = Blockchain.nextPointer;
+const subPointer = u256.fromU64(1).toUint8Array(true);
+
+// Create storage key
+const pointerHash = encodePointer(pointer, subPointer);
+
+// Write value
+Blockchain.setStorageAt(pointerHash, u256.fromU64(100).toUint8Array(true));
+
+// Read value
+const stored = Blockchain.getStorageAt(pointerHash);
+const value = u256.fromUint8ArrayBE(stored);
+```
+
+## Best Practices
+
+### 1. Declare Pointers First
+
+```typescript
+class MyContract extends OP_NET {
+    // Declare all pointers before any stored values
+    private ptr1: u16 = Blockchain.nextPointer;
+    private ptr2: u16 = Blockchain.nextPointer;
+    private ptr3: u16 = Blockchain.nextPointer;
+
+    // Then declare stored values
+    private _value1: StoredU256;
+    private _value2: StoredBoolean;
+
+    public constructor() {
+        super();
+        this._value1 = new StoredU256(this.ptr1, EMPTY_POINTER);
+        this._value2 = new StoredBoolean(this.ptr2, false);
+    }
+}
+```
+
+### 2. Use Appropriate Types
+
+```typescript
+// Good - use smallest type that fits
+private _count: StoredU32;  // If count < 4 billion
+
+// Less efficient
+private _count: StoredU256;  // Uses more storage
+```
+
+### 3. Batch Updates
+
+```typescript
+// Multiple related updates in one call
+public updateBoth(a: u256, b: u256): void {
+    this._valueA.value = a;
+    this._valueB.value = b;
+}
+```
+
+## Solidity Comparison
+
+| Solidity | OPNet Storage |
+|----------|---------------|
+| `uint256 public value` | `StoredU256` |
+| `mapping(address => uint256)` | `AddressMemoryMap` |
+| `mapping(address => mapping(address => uint256))` | `MapOfMap<u256>` |
+| `uint256[] public array` | `StoredU256Array` |
+| `bool public paused` | `StoredBoolean` |
+| `string public name` | `StoredString` |
+| `address public owner` | `StoredAddress` |
+
+---
+
+**Navigation:**
+- Previous: [SafeMath API](./safe-math.md)
+- Next: [Events API](./events.md)