@btc-vision/btc-runtime 1.4.6 → 1.5.0

package/runtime/storage/StoredBoolean.ts

@@ -1,51 +1,56 @@
-import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Blockchain } from '../env';
+import { GET_EMPTY_BUFFER } from '../math/bytes';
+import { Revert } from '../types/Revert';
 
 @final
 export class StoredBoolean {
-    private readonly u256Pointer: u256;
+    private readonly pointerBuffer: Uint8Array;
 
     constructor(
         public pointer: u16,
-        private defaultValue: bool,
+        defaultValue: bool,
     ) {
-        this.u256Pointer = u256.from(pointer);
+        const pointerBuffer = GET_EMPTY_BUFFER();
+        pointerBuffer[0] = pointer & 255;
+        pointerBuffer[1] = (pointer << 8) & 255;
+
+        this.pointerBuffer = pointerBuffer;
+
+        const value = GET_EMPTY_BUFFER();
+        if (defaultValue) {
+            value[0] = 1;
+        }
+
+        this._value = value;
     }
 
-    private _value: u256 = u256.Zero;
+    private _value: Uint8Array;
 
     @inline
     public get value(): bool {
         this.ensureValue();
 
-        return this._value.toBool();
+        return this._value[0] === 1;
     }
 
-    @inline
     public set value(value: bool) {
-        this._value = value ? u256.One : u256.Zero;
-
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
-    }
-
-    @inline
-    public set(value: u256): this {
-        this._value = value;
-
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        this._value[0] = value ? 1 : 0;
 
-        return this;
+        Blockchain.setStorageAt(this.pointerBuffer, this._value);
     }
 
     @inline
     public toUint8Array(): Uint8Array {
-        return this._value.toUint8Array(true);
+        if (!this._value) {
+            throw new Revert(`Not defined.`);
+        }
+
+        return this._value;
     }
 
     private ensureValue(): void {
         this._value = Blockchain.getStorageAt(
-            this.u256Pointer,
-            this.defaultValue ? u256.One : u256.Zero,
+            this.pointerBuffer,
         );
     }
 }

package/runtime/storage/StoredString.ts

@@ -1,148 +1,204 @@
-import { u256 } from '@btc-vision/as-bignum/assembly';
-import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
+import { bigEndianAdd } from '../math/bytes';
+import { Revert } from '../types/Revert';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 import { SafeMath } from '../types/SafeMath';
-import { U256_BYTE_LENGTH } from '../utils/lengths';
 
+const MAX_LENGTH = <u32>u16.MAX_VALUE;
+const MAX_LENGTH_U256 = u256.fromU32(<u32>MAX_LENGTH);
+
+/**
+ * @class StoredString
+ * @description
+ * Stores a string in a sequence of 32-byte storage slots, in UTF-8 format:
+ *  - Slot 0: first 4 bytes = length (big-endian), next 28 bytes = partial data
+ *  - Slot N>0: 32 bytes of data each
+ *
+ * The maximum is 65,535 bytes in UTF-8 form (not necessarily the same as code points).
+ */
 @final
 export class StoredString {
-    constructor(public pointer: u16, private defaultValue?: string) {}
+    private readonly subPointer: Uint8Array;
+
+    constructor(public pointer: u16, index: u64 = 0) {
+        const indexed = SafeMath.mul(u256.fromU64(index), MAX_LENGTH_U256);
+        this.subPointer = indexed.toUint8Array(true).slice(0, 30);
+    }
 
     private _value: string = '';
 
-    @inline
+    /**
+     * Cached string value. If `_value` is empty, we call `load()` on first access.
+     */
     public get value(): string {
         if (!this._value) {
             this.load();
         }
-
         return this._value;
     }
 
-    @inline
-    public set value(value: string) {
-        this._value = value;
+    public set value(v: string) {
+        this._value = v;
+
         this.save();
     }
 
-    private min(a: u32, b: u32): u32 {
-        return a < b ? a : b;
+    /**
+     * Derives a 32-byte pointer for the given chunkIndex and performs big-endian addition.
+     * chunkIndex=0 => header slot, 1 => second slot, etc.
+     */
+    private getPointer(chunkIndex: u64): Uint8Array {
+        const base = encodePointer(this.pointer, this.subPointer);
+        return bigEndianAdd(base, chunkIndex);
     }
 
-    private getPointer(key: u256): u256 {
-        const buf = new BytesWriter(U256_BYTE_LENGTH);
-        buf.writeU256(key);
-
-        return encodePointer(this.pointer, buf.getBuffer());
+    /**
+     * Reads the first slot and returns the stored byte length (big-endian).
+     * Returns 0 if the slot is all zero.
+     */
+    private getStoredLength(): u32 {
+        const headerSlot = Blockchain.getStorageAt(this.getPointer(0));
+        const b0 = <u32>headerSlot[0];
+        const b1 = <u32>headerSlot[1];
+        const b2 = <u32>headerSlot[2];
+        const b3 = <u32>headerSlot[3];
+        return (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
     }
 
-    private save(): void {
-        const length: u32 = this._value.length;
-        if (length == 0) {
+    /**
+     * Clears old data from storage. Based on `oldLength`, determines how many slots
+     * were used, and writes zeroed 32-byte arrays to each.
+     */
+    private clearOldStorage(oldLength: u32): void {
+        if (oldLength == 0) {
             return;
         }
 
-        if (length > 2048) {
-            throw new Error('StoredString: value is too long');
-        }
-
-        // Prepare the header with the length of the string in the first 4 bytes
-        let header: u256 = u256.fromU32(length);
-        header = SafeMath.shl(header, 224);
+        // We always use at least 1 slot (the header slot).
+        let chunkCount: u64 = 1;
 
-        let currentPointer: u256 = u256.Zero;
-        let remainingLength: u32 = length;
-        let offset: u32 = 0;
-
-        // Save the initial chunk (first 28 bytes) in the header
-        let bytesToWrite: u32 = this.min(remainingLength, 28);
-        header = this.saveChunk(header, this._value, offset, bytesToWrite, 4);
-        Blockchain.setStorageAt(this.getPointer(currentPointer), header);
-
-        remainingLength -= bytesToWrite;
-        offset += bytesToWrite;
-
-        // Save the remaining chunks in subsequent storage slots
-        while (remainingLength > 0) {
-            bytesToWrite = this.min(remainingLength, 32);
-            const storageValue: u256 = this.saveChunk(
-                u256.Zero,
-                this._value,
-                offset,
-                bytesToWrite,
-                0,
-            );
-            currentPointer = u256.add(currentPointer, u256.One);
-            Blockchain.setStorageAt(this.getPointer(currentPointer), storageValue);
-
-            remainingLength -= bytesToWrite;
-            offset += bytesToWrite;
+        // In the header slot, we can store up to 28 bytes of data.
+        const remaining = oldLength > 28 ? oldLength - 28 : 0;
+        if (remaining > 0) {
+            // Each additional chunk is 32 bytes.
+            // Use integer math ceiling: (remaining + 32 - 1) / 32
+            chunkCount += (remaining + 32 - 1) / 32;
         }
-    }
 
-    // Helper method to save a chunk of the string into the storage slot
-    private saveChunk(
-        storage: u256,
-        value: string,
-        offset: u32,
-        length: u32,
-        storageOffset: u32,
-    ): u256 {
-        const bytes = storage.toBytes(true);
-        for (let i: u32 = 0; i < length; i++) {
-            const index: i32 = i32(offset + i);
-            bytes[i + storageOffset] = u8(value.charCodeAt(index));
+        // Zero out each previously used slot
+        for (let i: u64 = 0; i < chunkCount; i++) {
+            Blockchain.setStorageAt(this.getPointer(i), new Uint8Array(32));
         }
-        return u256.fromBytes(bytes, true);
     }
 
-    private load(): void {
-        const header: u256 = Blockchain.getStorageAt(this.getPointer(u256.Zero), u256.Zero);
-        if (u256.eq(header, u256.Zero)) {
-            if (this.defaultValue) {
-                this.value = this.defaultValue;
-            }
+    /**
+     * Saves the current string to storage in UTF-8 form.
+     */
+    private save(): void {
+        // 1) Clear old data
+        const oldLen = this.getStoredLength();
+        this.clearOldStorage(oldLen);
 
-            return;
+        // 2) Encode new string as UTF-8
+        const utf8Data = String.UTF8.encode(this._value, false);
+        const length = <u32>utf8Data.byteLength;
+
+        // Enforce max length
+        if (length > MAX_LENGTH) {
+            throw new Revert(`StoredString: value is too long (max=${MAX_LENGTH})`);
         }
 
-        // the length of the string is stored in the first 4 bytes of the header
-        const bits: u256 = u256.shr(header, 224);
-        const length: u32 = bits.toU32();
+        // 3) If new string is empty, just store a zeroed header and return
+        if (length == 0) {
+            // A zeroed 32-byte array => indicates length=0
+            Blockchain.setStorageAt(this.getPointer(0), new Uint8Array(32));
+            return;
+        }
 
-        // the rest contains the string itself
-        let currentPointer: u256 = u256.Zero;
-        let remainingLength: u32 = length;
-        let currentStorage: u256 = header;
+        // 4) Write the first slot: length + up to 28 bytes
+        let remaining: u32 = length;
+        let offset: u32 = 0;
+        const firstSlot = new Uint8Array(32);
+        firstSlot[0] = <u8>((length >> 24) & 0xff);
+        firstSlot[1] = <u8>((length >> 16) & 0xff);
+        firstSlot[2] = <u8>((length >> 8) & 0xff);
+        firstSlot[3] = <u8>(length & 0xff);
+
+        const bytes = Uint8Array.wrap(utf8Data);
+        const firstChunkSize = remaining < 28 ? remaining : 28;
+        for (let i: u32 = 0; i < firstChunkSize; i++) {
+            firstSlot[4 + i] = bytes[i];
+        }
+        Blockchain.setStorageAt(this.getPointer(0), firstSlot);
+
+        remaining -= firstChunkSize;
+        offset += firstChunkSize;
+
+        // 5) Write subsequent slots (32 bytes each)
+        let chunkIndex: u64 = 1;
+        while (remaining > 0) {
+            const slotData = new Uint8Array(32);
+            const chunkSize = remaining < u32(32) ? remaining : u32(32);
+            for (let i: u32 = 0; i < chunkSize; i++) {
+                slotData[i] = bytes[offset + i];
+            }
+            Blockchain.setStorageAt(this.getPointer(chunkIndex), slotData);
 
-        const bytesToRead: u32 = this.min(remainingLength, 28);
-        let str: string = this.loadChunk(currentStorage, 4, bytesToRead);
-        remainingLength -= bytesToRead;
+            remaining -= chunkSize;
+            offset += chunkSize;
+            chunkIndex++;
+        }
+    }
 
-        while (remainingLength > 0) {
-            // Move to the next storage slot
-            currentPointer = u256.add(currentPointer, u256.One);
-            currentStorage = Blockchain.getStorageAt(this.getPointer(currentPointer), u256.Zero);
+    /**
+     * Loads the string from storage by reading the stored byte length, then decoding
+     * the corresponding UTF-8 data from the slots.
+     */
+    private load(): void {
+        // Read the header slot first
+        const headerSlot = Blockchain.getStorageAt(this.getPointer(0));
 
-            // Extract the relevant portion of the string from the current storage slot
-            const bytesToRead: u32 = this.min(remainingLength, 32);
-            str += this.loadChunk(currentStorage, 0, bytesToRead);
+        // Parse the big-endian length
+        const b0 = <u32>headerSlot[0];
+        const b1 = <u32>headerSlot[1];
+        const b2 = <u32>headerSlot[2];
+        const b3 = <u32>headerSlot[3];
+        const length: u32 = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
 
-            remainingLength -= bytesToRead;
+        // If length=0, then the string is empty
+        if (length == 0) {
+            this._value = '';
+            return;
         }
 
-        this._value = str;
-    }
-
-    private loadChunk(value: u256, offset: u32, length: u32): string {
-        const bytes = value.toBytes(true);
+        // Read the UTF-8 bytes from storage
+        let remaining: u32 = length;
+        let offset: u32 = 0;
+        const out = new Uint8Array(length);
 
-        let str: string = '';
-        for (let i: u32 = 0; i < length; i++) {
-            str += String.fromCharCode(bytes[i + offset]);
+        // First slot can hold up to 28 bytes after the length
+        const firstChunkSize = remaining < 28 ? remaining : 28;
+        for (let i: u32 = 0; i < firstChunkSize; i++) {
+            out[i] = headerSlot[4 + i];
+        }
+        remaining -= firstChunkSize;
+        offset += firstChunkSize;
+
+        // Read the subsequent slots of 32 bytes each
+        let chunkIndex: u64 = 1;
+        while (remaining > 0) {
+            const slotData = Blockchain.getStorageAt(this.getPointer(chunkIndex));
+            const chunkSize = remaining < 32 ? remaining : 32;
+            for (let i: u32 = 0; i < chunkSize; i++) {
+                out[offset + i] = slotData[i];
+            }
+            remaining -= chunkSize;
+            offset += chunkSize;
+            chunkIndex++;
         }
 
-        return str;
+        // Decode UTF-8 into a normal string
+        this._value = String.UTF8.decode(out.buffer, false);
     }
-}
+}

package/runtime/storage/StoredU256.ts

@@ -1,36 +1,29 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
-import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
-import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { SafeMath } from '../types/SafeMath';
-import { U256_BYTE_LENGTH } from '../utils/lengths';
 
 @final
 export class StoredU256 {
-    private readonly u256Pointer: u256;
+    private readonly pointerBuffer: Uint8Array;
 
     constructor(
         public pointer: u16,
-        public subPointer: MemorySlotPointer,
-        private defaultValue: u256,
+        public subPointer: Uint8Array,
     ) {
-        const writer = new BytesWriter(U256_BYTE_LENGTH);
-        writer.writeU256(subPointer);
+        assert(subPointer.length <= 30, `You must pass a 30 bytes sub-pointer. (Address, got ${subPointer.length})`);
 
-        this.u256Pointer = encodePointer(pointer, writer.getBuffer());
+        this.pointerBuffer = encodePointer(pointer, subPointer);
     }
 
     private _value: u256 = u256.Zero;
 
-    @inline
     public get value(): u256 {
         this.ensureValue();
 
         return this._value;
     }
 
-    @inline
     public set value(value: u256) {
         if (u256.eq(value, this._value)) {
             return;
@@ -38,12 +31,15 @@ export class StoredU256 {
 
         this._value = value;
 
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
     }
 
-    @inline
     public get toBytes(): Uint8Array {
-        return this._value.toUint8Array(false);
+        return this._value.toUint8Array(true);
+    }
+
+    private get __value(): Uint8Array {
+        return this._value.toUint8Array(true);
     }
 
     @inline
@@ -57,7 +53,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.add(this._value, value);
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -78,7 +74,7 @@ export class StoredU256 {
 
     @inline
     public commit(): this {
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -89,7 +85,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.sub(this._value, value);
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -100,7 +96,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.mul(this._value, value);
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -159,7 +155,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.shr(this._value, value);
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -170,7 +166,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.and(this._value, value);
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -181,7 +177,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.or(this._value, value);
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -192,7 +188,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.xor(this._value, value);
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -203,7 +199,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.pow(this._value, exponent);
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -214,7 +210,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.mod(this._value, value);
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -225,7 +221,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.add(this._value, u256.One);
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -236,7 +232,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.sub(this._value, u256.One);
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -245,7 +241,7 @@ export class StoredU256 {
     public set(value: u256): this {
         this._value = value;
 
-        Blockchain.setStorageAt(this.u256Pointer, this._value);
+        Blockchain.setStorageAt(this.pointerBuffer, this.__value);
 
         return this;
     }
@@ -256,6 +252,7 @@ export class StoredU256 {
     }
 
     private ensureValue(): void {
-        this._value = Blockchain.getStorageAt(this.u256Pointer, this.defaultValue);
+        const value = Blockchain.getStorageAt(this.pointerBuffer);
+        this._value = u256.fromUint8ArrayBE(value);
     }
 }

package/runtime/storage/StoredU64.ts

@@ -2,8 +2,7 @@ import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
-import { MemorySlotPointer } from '../memory/MemorySlotPointer';
-import { U256_BYTE_LENGTH } from '../utils/lengths';
+import { BytesReader } from '../buffer/BytesReader';
 
 /**
  * @class StoredU64
@@ -11,7 +10,7 @@ import { U256_BYTE_LENGTH } from '../utils/lengths';
  */
 @final
 export class StoredU64 {
-    private readonly u256Pointer: u256;
+    private readonly bufferPointer: Uint8Array;
 
     // Internal cache for four u64 values: [lo1, lo2, hi1, hi2]
     private _values: u64[] = [0, 0, 0, 0];
@@ -25,18 +24,15 @@ export class StoredU64 {
     /**
      * @constructor
      * @param {u16} pointer - The primary pointer identifier.
-     * @param {MemorySlotPointer} subPointer - The sub-pointer for memory slot addressing.
-     * @param {u256} defaultValue - The default u256 value if storage is uninitialized.
+     * @param {Uint8Array} subPointer - The sub-pointer for memory slot addressing.
      */
     constructor(
         public pointer: u16,
-        public subPointer: MemorySlotPointer,
-        private defaultValue: u256,
+        public subPointer: Uint8Array,
     ) {
-        const writer = new BytesWriter(U256_BYTE_LENGTH);
-        writer.writeU256(subPointer);
+        assert(subPointer.length <= 30, `You must pass a 30 bytes sub-pointer. (StoredU64, got ${subPointer.length})`);
 
-        this.u256Pointer = encodePointer(pointer, writer.getBuffer());
+        this.bufferPointer = encodePointer(pointer, subPointer);
     }
 
     /**
@@ -75,7 +71,7 @@ export class StoredU64 {
     public save(): void {
         if (this.isChanged) {
             const packed = this.packValues();
-            Blockchain.setStorageAt(this.u256Pointer, packed);
+            Blockchain.setStorageAt(this.bufferPointer, packed);
             this.isChanged = false;
         }
     }
@@ -122,17 +118,6 @@ export class StoredU64 {
         return `[${this._values[0].toString()}, ${this._values[1].toString()}, ${this._values[2].toString()}, ${this._values[3].toString()}]`;
     }
 
-    /**
-     * @method toBytes
-     * @description Returns the packed u256 value as a byte array.
-     * @returns {Uint8Array} - The packed u256 value in byte form.
-     */
-    @inline
-    public toBytes(): u8[] {
-        this.ensureValues();
-        const packed = this.packValues();
-        return packed.toBytes();
-    }
 
     /**
      * @method reset
@@ -151,13 +136,14 @@ export class StoredU64 {
      */
     private ensureValues(): void {
         if (!this.isLoaded) {
-            const storedU256: u256 = Blockchain.getStorageAt(this.u256Pointer, this.defaultValue);
+            const storedU256: Uint8Array = Blockchain.getStorageAt(this.bufferPointer);
+
+            const reader = new BytesReader(storedU256);
 
-            // Unpack the stored u256 into four u64s
-            this._values[0] = storedU256.lo1;
-            this._values[1] = storedU256.lo2;
-            this._values[2] = storedU256.hi1;
-            this._values[3] = storedU256.hi2;
+            this._values[0] = reader.readU64();
+            this._values[1] = reader.readU64();
+            this._values[2] = reader.readU64();
+            this._values[3] = reader.readU64();
 
             this.isLoaded = true;
         }
@@ -169,12 +155,14 @@ export class StoredU64 {
      * @description Packs the four cached u64 values into a single u256 for storage.
      * @returns {u256} - The packed u256 value.
      */
-    private packValues(): u256 {
-        return new u256(
-            this._values[0], // lo1
-            this._values[1], // lo2
-            this._values[2], // hi1
-            this._values[3], // hi2
-        );
+    private packValues(): Uint8Array {
+        const writer = new BytesWriter(32);
+
+        writer.writeU64(this._values[0]);
+        writer.writeU64(this._values[1]);
+        writer.writeU64(this._values[2]);
+        writer.writeU64(this._values[3]);
+
+        return writer.getBuffer();
     }
 }