@btc-vision/btc-runtime 1.10.2 → 1.10.4

package/runtime/generic/AddressMap.ts

@@ -1,60 +1,149 @@
-import { Revert } from '../types/Revert';
-import { Map } from './Map';
 import { Address } from '../types/Address';
+import { Revert } from '../types/Revert';
+import { IMap } from './Map';
 
 @final
-export class AddressMap<V> extends Map<Address, V> {
+export class AddressMap<V> implements IMap<Address, V> {
+    protected _keys: Address[] = [];
+    protected _values: V[] = [];
+
+    // CACHE: Stores the index of the last successful lookup to make repeated access O(1)
+    private _lastIndex: i32 = -1;
+
+    @inline
+    public get size(): i32 {
+        return this._keys.length;
+    }
+
+    @inline
+    public keys(): Address[] {
+        return this._keys;
+    }
+
+    @inline
+    public values(): V[] {
+        return this._values;
+    }
+
     public set(key: Address, value: V): this {
-        const index: i32 = this.indexOf(key);
+        let index = -1;
+
+        // Check Cache (Fastest)
+        if (this._lastIndex !== -1) {
+            const cachedKey = unchecked(this._keys[this._lastIndex]);
+            // Check length first, then full content equality
+            if (cachedKey.length === key.length) {
+                if (memory.compare(cachedKey.dataStart, key.dataStart, key.length) === 0) {
+                    index = this._lastIndex;
+                }
+            }
+        }
+
+        // Full Scan if cache missed
+        if (index === -1) {
+            index = this.indexOf(key);
+        }
+
         if (index === -1) {
             this._keys.push(key);
             this._values.push(value);
+            this._lastIndex = this._keys.length - 1;
         } else {
-            this._values[index] = value;
+            unchecked((this._values[index] = value));
+            // Cache is already pointing to this index (from indexOf or the check above)
+            this._lastIndex = index;
         }
 
         return this;
     }
 
-    public indexOf(address: Address): i32 {
-        for (let i: i32 = 0; i < this._keys.length; i++) {
-            const key = this._keys[i];
+    /**
+     * HYPER-OPTIMIZED SEARCH
+     * Scans for Data Equality (not object equality).
+     * Uses a "Prefix Filter" to skip expensive memory comparisons.
+     */
+    public indexOf(pointerHash: Address): i32 {
+        const len = this._keys.length;
+        if (len === 0) return -1;
+
+        const ptrLen = pointerHash.length;
+        const ptrData = pointerHash.dataStart;
 
-            if (address.equals(key)) {
-                return i;
+        // OPTIMIZATION: Prefix Filter
+        // If keys are long enough (hashes/addresses), we compare the first 8 bytes as a simple integer.
+        // This is 1 CPU cycle vs ~30+ cycles for a function call loop.
+        if (ptrLen >= 8) {
+            // Read the first 8 bytes of the SEARCH NEEDLE
+            const searchHeader = load<u64>(ptrData);
+
+            // Loop Backwards (finding most recently added items first is usually better for contracts)
+            for (let i = len - 1; i >= 0; i--) {
+                const key = unchecked(this._keys[i]);
+
+                // Cheap Length Check
+                if (key.length !== ptrLen) continue;
+
+                // Cheap Integer Check (The Prefix Filter)
+                // This reads the CONTENT of the key, not the object pointer.
+                // If the first 8 bytes of data don't match, we skip the expensive check.
+                if (load<u64>(key.dataStart) !== searchHeader) continue;
+
+                // Expensive Full Check
+                // Only runs if length AND first 8 bytes match.
+                if (memory.compare(key.dataStart, ptrData, ptrLen) === 0) {
+                    this._lastIndex = i;
+                    return i;
+                }
+            }
+        } else {
+            // Fallback for small keys (< 8 bytes)
+            for (let i = len - 1; i >= 0; i--) {
+                const key = unchecked(this._keys[i]);
+                if (key.length !== ptrLen) continue;
+
+                if (memory.compare(key.dataStart, ptrData, ptrLen) === 0) {
+                    this._lastIndex = i;
+                    return i;
+                }
             }
         }
 
         return -1;
     }
 
+    @inline
     public has(key: Address): bool {
-        for (let i: i32 = 0; i < this._keys.length; i++) {
-            if (key.equals(this._keys[i])) {
-                return true;
-            }
-        }
-
-        return false;
+        return this.indexOf(key) !== -1;
     }
 
     public get(key: Address): V {
-        const index: i32 = this.indexOf(key);
+        const index = this.indexOf(key);
         if (index === -1) {
-            throw new Revert('Key not found in map (AddressMap)');
+            throw new Revert('Key not found in map');
         }
-        return this._values[index];
+        return unchecked(this._values[index]);
     }
 
     public delete(key: Address): bool {
-        const index: i32 = this.indexOf(key);
-        if (index === -1) {
-            return false;
-        }
+        const index = this.indexOf(key);
+        if (index === -1) return false;
 
         this._keys.splice(index, 1);
         this._values.splice(index, 1);
 
+        this._lastIndex = -1;
+
         return true;
     }
+
+    @inline
+    public clear(): void {
+        this._keys = [];
+        this._values = [];
+        this._lastIndex = -1;
+    }
+
+    public toString(): string {
+        return `Map(size=${this._keys.length})`;
+    }
 }

package/runtime/generic/Map.ts

@@ -2,19 +2,13 @@ import { Revert } from '../types/Revert';
 
 export interface IMap<K, V> {
     readonly size: i32;
-
     has(key: K): bool;
-
     set(key: K, value: V): this;
-
     get(key: K): V;
-
     delete(key: K): bool;
-
     clear(): void;
-
-    keys(): K[]; // preliminary
-    values(): V[]; // preliminary
+    keys(): K[];
+    values(): V[];
     toString(): string;
 }
 
@@ -22,33 +16,69 @@ export class Map<K, V> implements IMap<K, V> {
     protected _keys: K[] = [];
     protected _values: V[] = [];
 
+    // OPTIMIZATION: Cache the last found index.
+    // This makes has() -> get() sequences O(1) for the second call.
+    protected _lastIndex: i32 = -1;
+
+    @inline
     public get size(): i32 {
         return this._keys.length;
     }
 
+    @inline
     public keys(): K[] {
         return this._keys;
     }
 
+    @inline
     public values(): V[] {
         return this._values;
     }
 
     public set(key: K, value: V): this {
-        const index: i32 = this.indexOf(key);
+        // Fast Cache Check
+        if (this._lastIndex != -1) {
+            if (unchecked(this._keys[this._lastIndex]) == key) {
+                unchecked((this._values[this._lastIndex] = value));
+                return this;
+            }
+        }
+
+        // Full Scan
+        const index = this.indexOf(key);
+
         if (index == -1) {
             this._keys.push(key);
             this._values.push(value);
+            // Update cache to new item
+            this._lastIndex = this._keys.length - 1;
         } else {
-            this._values[index] = value;
+            unchecked((this._values[index] = value));
+            // Update cache to found item (indexOf updates it too, but explicit here for safety)
+            this._lastIndex = index;
         }
 
         return this;
     }
 
+    /**
+     * Optimized Linear Scan.
+     * Iterates backwards (LIFO assumption: recent items are hotter).
+     */
     public indexOf(key: K): i32 {
-        for (let i: i32 = 0; i < this._keys.length; i++) {
-            if (this._keys[i] == key) {
+        const len = this._keys.length;
+
+        // Optimization: Check cache first
+        if (this._lastIndex != -1 && this._lastIndex < len) {
+            if (unchecked(this._keys[this._lastIndex]) == key) {
+                return this._lastIndex;
+            }
+        }
+
+        // Reverse loop is often slightly faster for finding recent items
+        for (let i = len - 1; i >= 0; i--) {
+            if (unchecked(this._keys[i] == key)) {
+                this._lastIndex = i; // Update cache
                 return i;
             }
         }
@@ -57,40 +87,66 @@ export class Map<K, V> implements IMap<K, V> {
     }
 
     public get(key: K): V {
-        const index: i32 = this.indexOf(key);
+        const index = this.indexOf(key);
         if (index == -1) {
             throw new Revert('Key not found in map (Map)');
         }
-        return this._values[index];
+        return unchecked(this._values[index]);
     }
 
+    @inline
     public has(key: K): bool {
         return this.indexOf(key) != -1;
     }
 
+    /**
+     * Optimized Delete (Swap and Pop).
+     * O(1) complexity instead of O(N) splice.
+     */
     public delete(key: K): bool {
-        const index: i32 = this.indexOf(key);
+        const index = this.indexOf(key);
         if (index == -1) {
             return false;
         }
 
-        this._keys.splice(index, 1);
-        this._values.splice(index, 1);
+        const lastIndex = this._keys.length - 1;
+
+        // If the element to delete is not the last one, swap it with the last one
+        if (index != lastIndex) {
+            unchecked((this._keys[index] = this._keys[lastIndex]));
+            unchecked((this._values[index] = this._values[lastIndex]));
+
+            // Fix cache if we moved the cached item
+            if (this._lastIndex == lastIndex) {
+                this._lastIndex = index;
+            } else if (this._lastIndex == index) {
+                this._lastIndex = -1;
+            }
+        } else {
+            // We are deleting the tail
+            if (this._lastIndex == lastIndex) this._lastIndex = -1;
+        }
+
+        this._keys.pop();
+        this._values.pop();
+
         return true;
     }
 
+    @inline
     public clear(): void {
         this._keys = [];
         this._values = [];
+        this._lastIndex = -1;
     }
 
     public toString(): string {
-        const str: string = ``;
-
-        for (let i: i32 = 0; i < this._keys.length; i++) {
-            str.concat(`[${this._keys[i]}] => [${this._values[i]}]`);
+        // Warning: String concatenation in loops is O(N^2). Use sparingly.
+        let str = '';
+        const len = this._keys.length;
+        for (let i = 0; i < len; i++) {
+            str += `[${unchecked(this._keys[i])}] => [${unchecked(this._values[i])}]`;
         }
-
         return str;
     }
 }

package/runtime/generic/MapUint8Array.ts

@@ -1,14 +1,13 @@
 import { Revert } from '../types/Revert';
 import { IMap } from './Map';
 
+/**
+ * Optimized equality check using WASM intrinsic memory comparison.
+ */
+@inline
 export function eqUint(data: Uint8Array, data2: Uint8Array): bool {
     if (data.length !== data2.length) return false;
-
-    for (let i = 0; i < data.length; i++) {
-        if (data[i] !== data2[i]) return false;
-    }
-
-    return true;
+    return memory.compare(data.dataStart, data2.dataStart, data.length) === 0;
 }
 
 @final
@@ -16,78 +15,167 @@ export class MapUint8Array implements IMap<Uint8Array, Uint8Array> {
     protected _keys: Uint8Array[] = [];
     protected _values: Uint8Array[] = [];
 
+    // CACHE: Stores the index of the last successful lookup to make repeated access O(1)
+    private _lastIndex: i32 = -1;
+
+    @inline
     public get size(): i32 {
         return this._keys.length;
     }
 
+    @inline
     public keys(): Uint8Array[] {
         return this._keys;
     }
 
+    @inline
     public values(): Uint8Array[] {
         return this._values;
     }
 
     public set(key: Uint8Array, value: Uint8Array): this {
-        const index: i32 = this.indexOf(key);
+        let index = -1;
+
+        // Check Cache (Fastest)
+        if (this._lastIndex !== -1) {
+            const cachedKey = unchecked(this._keys[this._lastIndex]);
+            // Check length first, then full content equality
+            if (cachedKey.length === key.length) {
+                if (memory.compare(cachedKey.dataStart, key.dataStart, key.length) === 0) {
+                    index = this._lastIndex;
+                }
+            }
+        }
+
+        // Full Scan if cache missed
+        if (index === -1) {
+            index = this.indexOf(key);
+        }
+
         if (index === -1) {
             this._keys.push(key);
             this._values.push(value);
+            this._lastIndex = this._keys.length - 1;
         } else {
-            this._values[index] = value;
+            unchecked((this._values[index] = value));
+            // Cache is already pointing to this index (from indexOf or the check above)
+            this._lastIndex = index;
         }
 
         return this;
     }
 
+    /**
+     * HYPER-OPTIMIZED SEARCH
+     * Scans for Data Equality (not object equality).
+     * Uses a "Prefix Filter" to skip expensive memory comparisons.
+     */
     public indexOf(pointerHash: Uint8Array): i32 {
-        for (let i: i32 = 0; i < this._keys.length; i++) {
-            const key = this._keys[i];
-
-            if (eqUint(key, pointerHash)) {
-                return i;
+        const len = this._keys.length;
+        if (len === 0) return -1;
+
+        const ptrLen = pointerHash.length;
+        const ptrData = pointerHash.dataStart;
+
+        // OPTIMIZATION: Prefix Filter
+        // If keys are long enough (hashes/addresses), we compare the first 8 bytes as a simple integer.
+        // This is 1 CPU cycle vs ~30+ cycles for a function call loop.
+        if (ptrLen >= 8) {
+            // Read the first 8 bytes of the SEARCH NEEDLE
+            const searchHeader = load<u64>(ptrData);
+
+            // Loop Backwards (finding most recently added items first is usually better for contracts)
+            for (let i = len - 1; i >= 0; i--) {
+                const key = unchecked(this._keys[i]);
+
+                // Cheap Length Check
+                if (key.length !== ptrLen) continue;
+
+                // Cheap Integer Check (The Prefix Filter)
+                // This reads the CONTENT of the key, not the object pointer.
+                // If the first 8 bytes of data don't match, we skip the expensive check.
+                if (load<u64>(key.dataStart) !== searchHeader) continue;
+
+                // Expensive Full Check
+                // Only runs if length AND first 8 bytes match.
+                if (memory.compare(key.dataStart, ptrData, ptrLen) === 0) {
+                    this._lastIndex = i;
+                    return i;
+                }
+            }
+        } else {
+            // Fallback for small keys (< 8 bytes)
+            for (let i = len - 1; i >= 0; i--) {
+                const key = unchecked(this._keys[i]);
+                if (key.length !== ptrLen) continue;
+
+                if (memory.compare(key.dataStart, ptrData, ptrLen) === 0) {
+                    this._lastIndex = i;
+                    return i;
+                }
             }
         }
 
         return -1;
     }
 
+    @inline
     public has(key: Uint8Array): bool {
         return this.indexOf(key) !== -1;
     }
 
     public get(key: Uint8Array): Uint8Array {
-        const index: i32 = this.indexOf(key);
+        const index = this.indexOf(key);
         if (index === -1) {
             throw new Revert('Key not found in map (uint8array)');
         }
-        return this._values[index];
+        return unchecked(this._values[index]);
     }
 
     public delete(key: Uint8Array): bool {
-        const index: i32 = this.indexOf(key);
-        if (index === -1) {
-            return false;
+        const index = this.indexOf(key);
+        if (index === -1) return false;
+
+        const lastIndex = this._keys.length - 1;
+
+        // Swap and Pop (O(1) delete)
+        if (index !== lastIndex) {
+            // Move last element to the deleted position
+            unchecked((this._keys[index] = this._keys[lastIndex]));
+            unchecked((this._values[index] = this._values[lastIndex]));
+
+            // Update cache based on what was affected
+            if (this._lastIndex === lastIndex) {
+                // Cache pointed to last element, which moved to 'index'
+                this._lastIndex = index;
+            } else if (this._lastIndex === index) {
+                // Cache pointed to deleted element, invalidate it
+                this._lastIndex = -1;
+            }
+            // Note: If cache points to any other index, it remains valid
+            // because swap-and-pop only modifies positions 'index' and 'lastIndex'
+        } else {
+            // Deleting the last element (no swap needed)
+            if (this._lastIndex === lastIndex) {
+                this._lastIndex = -1;
+            }
+            // If cache points to any earlier index, it remains valid
         }
 
-        this._keys.splice(index, 1);
-        this._values.splice(index, 1);
+        this._keys.pop();
+        this._values.pop();
 
         return true;
     }
 
+    @inline
     public clear(): void {
         this._keys = [];
         this._values = [];
+        this._lastIndex = -1;
     }
 
     public toString(): string {
-        const str: string = ``;
-
-        for (let i: i32 = 0; i < this._keys.length; i++) {
-            str.concat(`[${this._keys[i].toString()}] => [${this._values[i].toString()}]`);
-        }
-
-        return str;
+        return `Map(size=${this._keys.length})`;
     }
 }

package/runtime/storage/StoredAddress.ts

@@ -15,7 +15,7 @@ export class StoredAddress {
         this.addressPointer = encodePointer(pointer, EMPTY_POINTER, true, 'StoredAddress');
     }
 
-    private _value: Address = Address.dead();
+    private _value: Address = Address.zero();
 
     public get value(): Address {
         this.ensureValue();
@@ -34,7 +34,7 @@ export class StoredAddress {
     }
 
     public isDead(): bool {
-        return eqUint(Address.dead(), this.value);
+        return eqUint(Address.zero(), this.value);
     }
 
     private ensureValue(): void {