@btc-vision/btc-runtime 1.3.9 → 1.3.10

package/package.json

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

package/runtime/contracts/DeployableOP_20.ts

@@ -284,7 +284,6 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     protected _transfer(to: Address, value: u256): boolean {
         const sender = Blockchain.tx.sender;
 
-        if (!this.balanceOfMap.has(sender)) throw new Revert();
         if (this.isSelf(sender)) throw new Revert('Can not transfer from self account');
 
         if (u256.eq(value, u256.Zero)) {

package/runtime/env/BlockchainEnvironment.ts

@@ -19,6 +19,7 @@ import {
     nextPointerGreaterThan,
     storePointer,
     validateBitcoinAddress,
+    verifySchnorrSignature,
 } from './global';
 import { DeployContractResponse } from '../interfaces/DeployContractResponse';
 import { MapU256 } from '../generic/MapU256';
@@ -248,6 +249,22 @@ export class BlockchainEnvironment {
         return reader.readU256();
     }
 
+    public verifySchnorrSignature(
+        publicKey: Address,
+        signature: Uint8Array,
+        hash: Uint8Array,
+    ): boolean {
+        const writer = new BytesWriter(128);
+        writer.writeBytes(publicKey);
+        writer.writeBytes(signature);
+        writer.writeBytes(hash);
+
+        const result: Uint8Array = verifySchnorrSignature(writer.getBuffer());
+
+        const reader = new BytesReader(result);
+        return reader.readBoolean();
+    }
+
     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/global.ts

@@ -53,3 +53,7 @@ export declare function inputs(): Uint8Array;
 // @ts-ignore
 @external('env', 'outputs')
 export declare function outputs(): Uint8Array;
+
+// @ts-ignore
+@external('env', 'verifySchnorrSignature')
+export declare function verifySchnorrSignature(data: Uint8Array): Uint8Array;

package/runtime/storage/StoredU128Array.ts

@@ -1,9 +1,8 @@
-import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { u128, u256 } from 'as-bignum/assembly';
 import { Blockchain } from '../env';
-import { encodePointer } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';
-import { u128, u256 } from 'as-bignum/assembly';
 import { SafeMath } from '../types/SafeMath';
+import { Revert } from '../types/Revert';
 
 /**
  * @class StoredU128Array
@@ -12,92 +11,239 @@ import { SafeMath } from '../types/SafeMath';
 @final
 export class StoredU128Array {
     private readonly baseU256Pointer: u256;
+    private readonly lengthPointer: u256;
+
+    // Internal cache for storage slots, each holding two u128 values
+    private _values: Map<u64, u128[]> = new Map(); // Map from slotIndex to array of two u128s
+    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 cache for multiple storage slots, each holding two u128 values
-    private _values: Array<u128[]> = []; // Each element is an array of two u128s
-    private _isLoaded: Array<bool> = []; // Indicates if the corresponding slot is loaded
-    private _isChanged: Array<bool> = []; // Indicates if the corresponding slot has been 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.MAX_VALUE - 1;
 
     /**
      * @constructor
      * @param {u16} pointer - The primary pointer identifier.
-     * @param {MemorySlotPointer} subPointer - The sub-pointer for memory slot addressing.
+     * @param {Uint8Array} subPointer - The sub-pointer for memory slot addressing.
      * @param {u256} defaultValue - The default u256 value if storage is uninitialized.
      */
     constructor(
         public pointer: u16,
-        public subPointer: MemorySlotPointer,
+        public subPointer: Uint8Array,
         private defaultValue: u256,
     ) {
         // Initialize the base u256 pointer using the primary pointer and subPointer
         const writer = new BytesWriter(32);
-        writer.writeU256(subPointer);
-        this.baseU256Pointer = encodePointer(pointer, writer.getBuffer());
+        writer.writeU16(pointer);
+        writer.writeBytes(subPointer);
+
+        // Initialize the length pointer (slot 0) where both length and startIndex are stored
+        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 u128 value at the specified global index.
-     * @param {u32} index - The global index (0 to ∞) of the u128 value to retrieve.
+     * @param {u64} index - The global index (0 to ∞) of the u128 value to retrieve.
      * @returns {u128} - The u128 value at the specified index.
      */
     @inline
-    public get(index: u32): u128 {
-        const slotIndex: u32 = index / 2; // Each slot holds two u128s
+    public get(index: u64): u128 {
+        assert(index < this._length, 'Index out of bounds');
+        const slotIndex: u32 = <u32>(index / 2); // Each slot holds two u128s
         const subIndex: u8 = <u8>(index % 2); // 0 or 1
         this.ensureValues(slotIndex);
-        return this._values[slotIndex][subIndex];
+        const slotValues = this._values.get(slotIndex);
+        if (slotValues) {
+            return slotValues[subIndex];
+        } else {
+            return u128.Zero; // Should not happen, as ensureValues should have loaded it
+        }
     }
 
     /**
      * @method set
      * @description Sets the u128 value at the specified global index.
-     * @param {u32} index - The global index (0 to ∞) of the u128 value to set.
+     * @param {u64} index - The global index (0 to ∞) of the u128 value to set.
      * @param {u128} value - The u128 value to assign.
      */
     @inline
-    public set(index: u32, value: u128): void {
-        const slotIndex: u32 = index / 2;
+    public set(index: u64, value: u128): void {
+        assert(index < this._length, 'Index exceeds current array length');
+        const slotIndex: u32 = <u32>(index / 2);
         const subIndex: u8 = <u8>(index % 2);
         this.ensureValues(slotIndex);
+        const slotValues = this._values.get(slotIndex);
+        if (slotValues) {
+            if (!u128.eq(slotValues[subIndex], value)) {
+                slotValues[subIndex] = value;
+                this._isChanged.add(slotIndex);
+            }
+        }
+    }
+
+    /**
+     * @method push
+     * @description Appends a new u128 value to the end of the array.
+     * @param {u128} value - The u128 value to append.
+     */
+    public push(value: u128): void {
+        if (this._length >= this.MAX_LENGTH) {
+            throw new Revert(
+                'Push operation failed: Array has reached its maximum allowed length.',
+            );
+        }
+
+        const newIndex: u64 = this._length;
+        const effectiveIndex: u64 = this._startIndex + newIndex;
+        const wrappedIndex: u64 =
+            effectiveIndex < this.MAX_LENGTH ? effectiveIndex : effectiveIndex % this.MAX_LENGTH;
+        const slotIndex: u32 = <u32>(wrappedIndex / 2);
+        const subIndex: u8 = <u8>(wrappedIndex % 2);
+
+        // Ensure the slot is loaded
+        this.ensureValues(slotIndex);
+
+        // Set the new value in the appropriate sub-index
+        const slotValues = this._values.get(slotIndex);
+        if (slotValues) {
+            slotValues[subIndex] = value;
+            this._isChanged.add(slotIndex);
+        }
+
+        // Increment the length
+        this._length += 1;
+        this._isChangedLength = true;
+    }
+
+    /**
+     * @method delete
+     * @description Deletes the u128 value at the specified index by setting it to zero. Does not reorder the array.
+     * @param {u64} index - The global index of the u128 value to delete.
+     */
+    public delete(index: u64): void {
+        if (index >= this._length) {
+            // If the index is out of bounds, revert the transaction
+            throw new Revert('Delete operation failed: Index out of bounds.');
+        }
+
+        const slotIndex: u32 = <u32>(index / 2);
+        const subIndex: u8 = <u8>(index % 2);
+        this.ensureValues(slotIndex);
+
+        const slotValues = this._values.get(slotIndex);
+        if (slotValues) {
+            // Set the targeted u128 to zero
+            if (!u128.eq(slotValues[subIndex], u128.Zero)) {
+                slotValues[subIndex] = u128.Zero;
+                this._isChanged.add(slotIndex);
+            }
+        }
+    }
+
+    /**
+     * @method shift
+     * @description Removes the first element of the array by setting it to zero, decrementing the length, and incrementing the startIndex.
+     *              If the startIndex reaches the maximum value of u64, it wraps around to 0.
+     */
+    public shift(): void {
+        if (this._length === 0) {
+            throw new Revert('Shift operation failed: Array is empty.');
+        }
+
+        const currentStartIndex: u64 = this._startIndex;
+        const slotIndex: u32 = <u32>(currentStartIndex / 2);
+        const subIndex: u8 = <u8>(currentStartIndex % 2);
+        this.ensureValues(slotIndex);
+
+        const slotValues = this._values.get(slotIndex);
+        if (slotValues) {
+            // Set the current start element to zero
+            if (!u128.eq(slotValues[subIndex], u128.Zero)) {
+                slotValues[subIndex] = u128.Zero;
+                this._isChanged.add(slotIndex);
+            }
+        }
+
+        // Decrement the length
+        this._length -= 1;
+        this._isChangedLength = true;
 
-        if (!u128.eq(this._values[slotIndex][subIndex], value)) {
-            this._values[slotIndex][subIndex] = value;
-            this._isChanged[slotIndex] = true;
+        // Increment the startIndex with wrap-around
+        if (this._startIndex < this.MAX_LENGTH - 1) {
+            this._startIndex += 1;
+        } else {
+            this._startIndex = 0;
         }
+        this._isChangedStartIndex = true;
     }
 
     /**
      * @method save
-     * @description Persists all cached u128 values to their respective storage slots if any have been modified.
+     * @description Persists all cached u128 values, the length, and the startIndex to their respective storage slots if any have been modified.
      */
     public save(): void {
-        const max: u32 = this._values.length;
-
-        for (let slotIndex: u32 = 0; slotIndex < max; slotIndex++) {
-            if (this._isChanged[slotIndex]) {
-                const packed = this.packValues(slotIndex);
-                const storagePointer = this.calculateStoragePointer(slotIndex);
-                Blockchain.setStorageAt(storagePointer, packed);
-                this._isChanged[slotIndex] = false;
-            }
+        // Save all changed slots
+        const values = this._isChanged.values();
+        for (let i: u32 = 0; i < <u32>values.length; i++) {
+            const slotIndex = values[i];
+            const packed = this.packValues(slotIndex);
+            const storagePointer = this.calculateStoragePointer(slotIndex);
+            Blockchain.setStorageAt(storagePointer, packed);
+        }
+        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 delete
-     * @description Deletes all storage slots by setting them to zero.
+     * @method deleteAll
+     * @description Deletes all storage slots by setting them to zero, including the length and startIndex slots.
      */
-    public delete(): void {
-        const max: u32 = this._values.length;
-        for (let slotIndex: u32 = 0; slotIndex < max; slotIndex++) {
+    public deleteAll(): void {
+        // Iterate over all loaded slots and clear them
+        const keys = this._values.keys();
+        for (let i = 0; i < keys.length; i++) {
+            const slotIndex = keys[i];
             const storagePointer = this.calculateStoragePointer(slotIndex);
             Blockchain.setStorageAt(storagePointer, u256.Zero);
         }
+
+        // Reset the length and startIndex to zero
+        const zeroLengthAndStartIndex = u256.Zero;
+        Blockchain.setStorageAt(this.lengthPointer, zeroLengthAndStartIndex);
+        this._length = 0;
+        this._startIndex = 0;
+        this._isChangedLength = false;
+        this._isChangedStartIndex = false;
+
         // Clear internal caches
-        this._values = [];
-        this._isLoaded = [];
-        this._isChanged = [];
+        this._values.clear();
+        this._isLoaded.clear();
+        this._isChanged.clear();
     }
 
     /**
@@ -109,7 +255,7 @@ export class StoredU128Array {
     @inline
     public setMultiple(startIndex: u32, values: u128[]): void {
         for (let i: u32 = 0; i < values.length; i++) {
-            this.set(startIndex + i, values[i]);
+            this.set(<u64>(startIndex + i), values[i]);
         }
     }
 
@@ -122,9 +268,10 @@ export class StoredU128Array {
      */
     @inline
     public getAll(startIndex: u32, count: u32): u128[] {
+        assert(startIndex + count <= this._length, 'Requested range exceeds array length');
         const result: u128[] = new Array<u128>(count);
         for (let i: u32 = 0; i < count; i++) {
-            result[i] = this.get(startIndex + i);
+            result[i] = this.get(<u64>(startIndex + i));
         }
         return result;
     }
@@ -137,13 +284,11 @@ export class StoredU128Array {
     @inline
     public toString(): string {
         let str = '[';
-        for (let slotIndex: u32 = 0; slotIndex < this._values.length; slotIndex++) {
-            for (let subIndex: u8 = 0; subIndex < 2; subIndex++) {
-                const value = this._values[slotIndex][subIndex];
-                str += value.toString();
-                if (!(slotIndex === this._values.length - 1 && subIndex === 1)) {
-                    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 += ']';
@@ -158,11 +303,14 @@ export class StoredU128Array {
     @inline
     public toBytes(): u8[] {
         const bytes: u8[] = new Array<u8>();
-        for (let slotIndex: u32 = 0; slotIndex < this._values.length; slotIndex++) {
-            const packed = this.packValues(slotIndex);
+        const slotCount: u32 = <u32>((this._length + 1) / 2);
+
+        for (let i: u32 = 0; i < slotCount; i++) {
+            this.ensureValues(i);
+            const packed = this.packValues(i);
             const slotBytes = packed.toBytes();
-            for (let i: u32 = 0; i < slotBytes.length; i++) {
-                bytes.push(slotBytes[i]);
+            for (let j: u32 = 0; j < slotBytes.length; j++) {
+                bytes.push(slotBytes[j]);
             }
         }
         return bytes;
@@ -170,40 +318,63 @@ export class StoredU128Array {
 
     /**
      * @method reset
-     * @description Resets all cached u128 values to zero and marks them as changed.
+     * @description Resets all cached u128 values to zero and marks them as changed, including resetting the length and startIndex.
      */
     @inline
     public reset(): void {
-        for (let slotIndex: u32 = 0; slotIndex < this._values.length; slotIndex++) {
-            for (let subIndex: u8 = 0; subIndex < 2; subIndex++) {
-                this._values[slotIndex][subIndex] = u128.Zero;
+        // Reset the length and startIndex to zero
+        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 setLength
+     * @description Sets the length of the array.
+     * @param {u64} newLength - The new length to set.
+     */
+    public setLength(newLength: u64): void {
+        if (newLength > this.MAX_LENGTH) {
+            throw new Revert('SetLength operation failed: Length exceeds maximum allowed value.');
+        }
+
+        if (newLength < this._length) {
+            // Truncate the array if newLength is smaller
+            for (let i: u64 = newLength; i < this._length; i++) {
+                this.delete(i);
             }
-            this._isChanged[slotIndex] = true;
         }
+
+        this._length = newLength;
+        this._isChangedLength = true;
     }
 
     /**
      * @private
      * @method ensureValues
-     * @description Loads and unpacks the u256 value from the specified storage slot into two u128 cache variables.
+     * @description Loads and caches the u128 values from the specified storage slot.
      * @param {u32} slotIndex - The index of the storage slot.
      */
     private ensureValues(slotIndex: u32): void {
-        // Initialize arrays if necessary
-        while (slotIndex >= <u32>this._isLoaded.length) {
-            this._isLoaded.push(false);
-            this._isChanged.push(false);
-            const newSlotValues: u128[] = new Array<u128>(2);
-            newSlotValues[0] = u128.Zero;
-            newSlotValues[1] = u128.Zero;
-            this._values.push(newSlotValues);
-        }
-
-        if (!this._isLoaded[slotIndex]) {
+        if (!this._isLoaded.has(slotIndex)) {
             const storagePointer = this.calculateStoragePointer(slotIndex);
             const storedU256: u256 = Blockchain.getStorageAt(storagePointer, this.defaultValue);
-            this._values[slotIndex] = this.unpackU256(storedU256);
-            this._isLoaded[slotIndex] = true;
+            const slotValues = this.unpackU256(storedU256);
+            this._values.set(slotIndex, slotValues);
+            this._isLoaded.add(slotIndex);
         }
     }
 
@@ -211,19 +382,17 @@ export class StoredU128Array {
      * @private
      * @method packValues
      * @description Packs the two cached u128 values into a single u256 for storage.
-     * @param {u32} slotIndex - The index of the storage slot.
+     * @param {u64} slotIndex - The index of the storage slot.
      * @returns {u256} - The packed u256 value.
      */
-    private packValues(slotIndex: u32): u256 {
-        const values = this._values[slotIndex];
+    private packValues(slotIndex: u64): u256 {
+        const values = this._values.get(slotIndex);
+        if (!values) {
+            // Should not happen, as ensureValues should have loaded it
+            return u256.Zero;
+        }
         const packed = new u256();
 
-        // Each u256 has lo1, lo2, hi1, hi2 as u64s
-        // Each u128 consists of two u64s
-        // Assign values accordingly:
-        // values[0] -> lo1 (first u64), lo2 (second u64)
-        // values[1] -> hi1 (third u64), hi2 (fourth u64)
-
         // Assign first u128
         packed.lo1 = values[0].lo;
         packed.lo2 = values[0].hi;
@@ -257,15 +426,11 @@ export class StoredU128Array {
     /**
      * @private
      * @method calculateStoragePointer
-     * @description Calculates the storage pointer for a given slot index by incrementing the subpointer.
-     * @param {u32} slotIndex - The index of the storage slot.
+     * @description Calculates the storage pointer for a given slot index by incrementing the base pointer.
+     * @param {u64} slotIndex - The index of the storage slot.
      * @returns {u256} - The calculated storage pointer.
      */
-    private calculateStoragePointer(slotIndex: u32): u256 {
-        // Clone the base subpointer and increment it by slotIndex
-        const modifiedSubPointer = this.baseU256Pointer.clone();
-        SafeMath.add(modifiedSubPointer, u256.fromU32(slotIndex));
-
-        return modifiedSubPointer;
+    private calculateStoragePointer(slotIndex: u64): u256 {
+        return SafeMath.add(this.baseU256Pointer, u256.fromU64(slotIndex + 1));
     }
 }