@btc-vision/btc-runtime 1.5.0 → 1.5.2

package/runtime/nested/codecs/NumericCodec.ts

@@ -0,0 +1,58 @@
+import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
+import { ICodec } from '../interfaces/ICodec';
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { BytesReader } from '../../buffer/BytesReader';
+import { idOfI128, idOfU128, idOfU256 } from './Ids';
+
+/**
+ * A generic NumericCodec<T> that handles:
+ *  - `u256` from @btc-vision/as-bignum (big-endian)
+ *  - Any built-in integer type (i32, u32, i64, etc.) also stored big-endian
+ */
+export class NumericCodec<T> implements ICodec<T> {
+    public encode(value: T): Uint8Array {
+        const id = idof<T>();
+        switch (id) {
+            case idOfU256: {
+                // T is `u256`
+                const val = changetype<u256>(value);
+                return val.toUint8Array(true); // big-endian
+            }
+            case idOfU128: {
+                // T is `u128`
+                const val = changetype<u128>(value);
+                return val.toUint8Array(true); // big-endian
+            }
+            case idOfI128: {
+                // T is `i128`
+                const val = changetype<i128>(value);
+                return val.toUint8Array(true); // big-endian
+            }
+            default: {
+                const writer = new BytesWriter(sizeof<T>());
+                writer.write<T>(value);
+
+                return writer.getBuffer();
+            }
+        }
+    }
+
+    public decode(buffer: Uint8Array): T {
+        const id = idof<T>();
+        switch (id) {
+            case idOfU256:
+                // T is `u256`
+                return changetype<T>(u256.fromBytes(buffer, true));
+            case idOfU128:
+                // T is `u128`
+                return changetype<T>(u128.fromBytes(buffer, true));
+            case idOfI128:
+                // T is `i128`
+                return changetype<T>(i128.fromBytes(buffer, true));
+            default: {
+                const writer = new BytesReader(buffer);
+                return writer.read<T>();
+            }
+        }
+    }
+}

package/runtime/nested/codecs/StringCodec.ts

@@ -0,0 +1,24 @@
+import { ICodec } from '../interfaces/ICodec';
+import { VariableBytesCodec } from './VariableBytesCodec';
+
+class IStringCodec implements ICodec<string> {
+    public encode(value: string): Uint8Array {
+        // Convert string -> UTF8 bytes
+        const utf8 = String.UTF8.encode(value, false);
+
+        // Pass to variable-bytes
+        return VariableBytesCodec.encode(Uint8Array.wrap(utf8));
+    }
+
+    public decode(buffer: Uint8Array): string {
+        const raw = VariableBytesCodec.decode(buffer);
+        if (raw.length == 0) {
+            return '';
+        }
+
+        return String.UTF8.decode(raw.buffer, false);
+    }
+}
+
+export const idOfStringCodec = idof<IStringCodec>();
+export const StringCodec = new IStringCodec();

package/runtime/nested/codecs/U256Codec.ts

@@ -0,0 +1,20 @@
+import { u256 } from '@btc-vision/as-bignum/assembly';
+import { ICodec } from '../interfaces/ICodec';
+
+class _U256Codec implements ICodec<u256> {
+    public encode(value: u256): Uint8Array {
+        // big-endian
+        return value.toUint8Array(true);
+    }
+
+    public decode(buffer: Uint8Array): u256 {
+        if (buffer.length == 0) {
+            return u256.Zero;
+        }
+
+        return u256.fromUint8ArrayBE(buffer);
+    }
+}
+
+export const idOfU256Codec = idof<_U256Codec>();
+export const U256Codec = new _U256Codec();

package/runtime/nested/codecs/VariableBytesCodec.ts

@@ -0,0 +1,134 @@
+import { ICodec } from '../interfaces/ICodec';
+import { PointerManager } from '../PointerManager';
+import { Blockchain } from '../../env';
+import { bigEndianAdd } from '../../math/bytes';
+
+/**
+ * A generic codec to store an arbitrary-length byte array ("payload") in chunked 32-byte slots.
+ * Layout:
+ *    - chunk 0 (pointer+0):
+ *         first 4 bytes = length (u32 big-endian),
+ *         next 28 bytes = partial data
+ *    - chunk i>0 (pointer + i): 32 bytes of subsequent data
+ */
+export class IVariableBytesCodec implements ICodec<Uint8Array> {
+    public encode(value: Uint8Array): Uint8Array {
+        const length = value.length;
+
+        // Number of bytes that fit in "the first chunk" = 28 (since 4 bytes used by length)
+        const firstChunkDataLen = length < 28 ? length : 28;
+        let remaining = length - firstChunkDataLen;
+
+        // If remaining > 0, each chunk is 32 bytes.
+        // So total chunks needed = 1 (for first chunk) + ceil(remaining / 32).
+        const additionalChunks: u32 = remaining == 0 ? 0 : ((remaining + 32 - 1) / 32);
+        const totalChunks: u32 = 1 + additionalChunks;
+
+        // 1) Allocate `totalChunks` from PointerManager
+        const pointerBytes = PointerManager.allocateSlots(totalChunks);
+
+        // 2) Write chunk 0: length + up to 28 bytes
+        const chunk0 = new Uint8Array(32);
+
+        // store length in big-endian (4 bytes)
+        chunk0[0] = <u8>((length >> 24) & 0xff);
+        chunk0[1] = <u8>((length >> 16) & 0xff);
+        chunk0[2] = <u8>((length >> 8) & 0xff);
+        chunk0[3] = <u8>(length & 0xff);
+
+        for (let i = 0; i < firstChunkDataLen; i++) {
+            chunk0[4 + i] = value[i];
+        }
+
+        // store chunk0
+        Blockchain.setStorageAt(pointerBytes, chunk0);
+
+        // 3) Write subsequent chunks
+        let offset: u32 = firstChunkDataLen;
+        for (let i: u64 = 1; i < u64(totalChunks); i++) {
+            const chunk = new Uint8Array(32);
+            const chunkSize: u32 = remaining < 32 ? remaining : 32;
+
+            for (let j: u32 = 0; j < chunkSize; j++) {
+                chunk[j] = value[offset + j];
+            }
+            
+            offset += chunkSize;
+            remaining -= chunkSize;
+
+            // compute pointer + i in big-endian
+            const chunkPointer = bigEndianAdd(pointerBytes, i);
+            Blockchain.setStorageAt(chunkPointer, chunk);
+        }
+
+        // 4) Return the pointer as the "encoded" data (32 bytes).
+        return pointerBytes;
+    }
+
+    public decode(buffer: Uint8Array): Uint8Array {
+        // If buffer is 0 or all zero => means no data
+        if (buffer.length == 0 || isAllZero(buffer)) {
+            return new Uint8Array(0);
+        }
+
+        const pointer = buffer; // the pointer (32 bytes)
+
+        // chunk0
+        const chunk0 = Blockchain.getStorageAt(pointer);
+        if (chunk0.length == 0) {
+            // No data stored => empty
+            return new Uint8Array(32);
+        }
+
+        // read length from first 4 bytes
+        const b0 = <u32>chunk0[0];
+        const b1 = <u32>chunk0[1];
+        const b2 = <u32>chunk0[2];
+        const b3 = <u32>chunk0[3];
+        const length = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
+
+        if (length == 0) {
+            return new Uint8Array(0);
+        }
+
+        // read the data
+        const out = new Uint8Array(length);
+        const firstChunkLen = length < 28 ? length : 28;
+
+        // copy from chunk0
+        for (let i: u32 = 0; i < firstChunkLen; i++) {
+            out[i] = chunk0[4 + i];
+        }
+
+        let offset = firstChunkLen;
+        let remaining = length - firstChunkLen;
+
+        // read subsequent chunks
+        let chunkIndex: u64 = 1;
+        while (remaining > 0) {
+            const chunkPointer = bigEndianAdd(pointer, chunkIndex);
+            const chunkData = Blockchain.getStorageAt(chunkPointer);
+            const chunkSize: u32 = remaining < 32 ? remaining : 32;
+
+            for (let j: u32 = 0; j < chunkSize; j++) {
+                out[offset + j] = chunkData[j];
+            }
+
+            offset += chunkSize;
+            remaining -= chunkSize;
+            chunkIndex++;
+        }
+
+        return out;
+    }
+}
+
+function isAllZero(arr: Uint8Array): bool {
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i] != 0) return false;
+    }
+    return true;
+}
+
+export const idOfVariableBytes = idof<IVariableBytesCodec>();
+export const VariableBytesCodec = new IVariableBytesCodec();

package/runtime/nested/interfaces/ICodec.ts

@@ -0,0 +1,12 @@
+export interface ICodec<T> {
+    /**
+     * Encode in-memory `value` into a buffer that will be stored in blockchain storage.
+     * Possibly a single 32-byte chunk or a pointer if more is needed.
+     */
+    encode(value: T): Uint8Array;
+
+    /**
+     * Decode a buffer from storage into an in-memory `T`.
+     */
+    decode(buffer: Uint8Array): T;
+}

package/runtime/nested/storage/StorageMap.ts

@@ -0,0 +1,227 @@
+import { Blockchain } from '../../env';
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { BytesReader } from '../../buffer/BytesReader';
+import { encodePointerUnknownLength } from '../../math/abi';
+
+import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
+import { idOfAddress, idOfI128, idOfString, idOfU128, idOfU256, idOfUint8Array } from '../codecs/Ids';
+
+import { AddressCodec } from '../codecs/AddressCodec';
+import { BooleanCodec } from '../codecs/BooleanCodec';
+import { StringCodec } from '../codecs/StringCodec';
+import { VariableBytesCodec } from '../codecs/VariableBytesCodec';
+import { U256Codec } from '../codecs/U256Codec';
+
+import { Address } from '../../types/Address';
+import { Revert } from '../../types/Revert';
+
+/**
+ * A reflection-based StorageMap<K, V>.
+ *  - `pointer` => a u16 "namespace"
+ *  - `set(key, value)` => store bytes
+ *  - `get(key)` => decode bytes
+ *
+ * This version uses a chain of `if/else` for each possible type T,
+ * so the compiler doesn't complain about mismatched returns.
+ */
+@final
+export class StorageMap<K, V> {
+    private readonly pointer: u16;
+
+    constructor(pointer: u16) {
+        this.pointer = pointer;
+    }
+
+    // ----------------------------------------------------------
+    // PUBLIC API
+    // ----------------------------------------------------------
+
+    public set(key: K, value: V): this {
+        const storageKey = this.getStorageKey(key);
+        this.storeValue<V>(storageKey, value);
+        return this;
+    }
+
+    public get(key: K): V {
+        const storageKey = this.getStorageKey(key);
+        return this.decodeValue<V>(storageKey);
+    }
+
+    public has(key: K): bool {
+        const storageKey = this.getStorageKey(key);
+        return Blockchain.hasStorageAt(storageKey);
+    }
+
+    @unsafe
+    public delete(key: K): bool {
+        const storageKey = this.getStorageKey(key);
+        if (!Blockchain.hasStorageAt(storageKey)) {
+            return false;
+        }
+
+        Blockchain.setStorageAt(storageKey, new Uint8Array(0));
+        return true;
+    }
+
+    @unsafe
+    public clear(): void {
+        // Not implemented: we'd need key-tracking to remove them all
+        throw new Error('clear() not implemented; no key-tracking logic here.');
+    }
+
+    // ----------------------------------------------------------
+    // INTERNAL: Derive the final storage key
+    // ----------------------------------------------------------
+
+    private getStorageKey(k: K): Uint8Array {
+        // 1) encode the key
+        const keyBytes = this.encodeValue<K>(k);
+
+        // 2) transform with pointer
+        return encodePointerUnknownLength(this.pointer, keyBytes);
+    }
+
+    // ----------------------------------------------------------
+    // ENCODE / DECODE
+    // ----------------------------------------------------------
+
+    /**
+     * Retrieve the value of type P from the given storage pointer (32 bytes).
+     * If it's a variable-length type, we decode from pointer-based approach
+     * (like VariableBytesCodec or StringCodec).
+     * Otherwise, we get the raw from storage and decode.
+     */
+    private decodeValue<P>(pointer: Uint8Array): P {
+        // For some types like `Uint8Array` or `string`, we might want
+        // to treat the pointer as an allocated "variable" location.
+        const typeId = idof<P>();
+
+        // For variable-length things:
+        if (typeId == idOfUint8Array) {
+            // decode variable bytes from pointer
+            const arr = VariableBytesCodec.decode(pointer);
+            return changetype<P>(arr);
+        }
+        if (typeId == idOfString) {
+            const str = StringCodec.decode(pointer);
+            return changetype<P>(str);
+        }
+
+        // For everything else, we read raw from storage
+        const raw = Blockchain.getStorageAt(pointer);
+
+        return this.decodeBytesAsType<P>(raw);
+    }
+
+    /**
+     * Store a value of type P at the given storage key.
+     * - Some types (uint8array, string) -> chunked (pointer-based).
+     * - Others -> direct bytes in that slot.
+     */
+    private storeValue<P>(storageKey: Uint8Array, value: P): void {
+        const raw = this.encodeValue<P>(value);
+        Blockchain.setStorageAt(storageKey, raw);
+    }
+
+    // ----------------------------------------------------------
+    // decodeBytesAsType: interpret raw bytes as type P
+    // ----------------------------------------------------------
+
+    private decodeBytesAsType<P>(raw: Uint8Array): P {
+        // isInteger => built-in numeric types (i32, u32, etc.)
+        if (isInteger<P>()) {
+            if (raw.length < <i32>sizeof<P>()) {
+                return changetype<P>(0);
+            }
+
+            const reader = new BytesReader(raw);
+            return reader.read<P>();
+        }
+
+        // isBoolean => decode with BooleanCodec
+        if (isBoolean<P>()) {
+            const boolVal = BooleanCodec.decode(raw);
+            return changetype<P>(boolVal);
+        }
+
+        const typeId = idof<P>();
+
+        // u256
+        if (typeId == idOfU256) {
+            const decoded = U256Codec.decode(raw);
+            return changetype<P>(decoded);
+        }
+
+        // i128
+        if (typeId == idOfI128) {
+            const val = i128.fromUint8ArrayBE(raw);
+            return changetype<P>(val);
+        }
+
+        // u128
+        if (typeId == idOfU128) {
+            const val = u128.fromUint8ArrayBE(raw);
+            return changetype<P>(val);
+        }
+
+        // Address
+        if (typeId == idOfAddress) {
+            const addr = AddressCodec.decode(raw);
+            return changetype<P>(addr);
+        }
+
+        throw new Revert(`Unsupported type ${typeId}`);
+    }
+
+    // ----------------------------------------------------------
+    // encodeValue<P>: convert a value of type P into raw bytes
+    // ----------------------------------------------------------
+
+    private encodeValue<P>(value: P): Uint8Array {
+        // built-in integer => write with BytesWriter
+        if (isInteger<P>()) {
+            const writer = new BytesWriter(sizeof<P>());
+            writer.write<P>(value);
+            return writer.getBuffer();
+        }
+
+        // bool => BooleanCodec
+        if (isBoolean<P>()) {
+            return BooleanCodec.encode(changetype<bool>(value));
+        }
+
+        // Check reflection for bigger types
+        if (value instanceof Uint8Array) {
+            return VariableBytesCodec.encode(value);
+        }
+
+        if (isString<P>()) {
+            const strVal = changetype<string>(value);
+            return StringCodec.encode(strVal);
+        }
+
+        if (value instanceof u256) {
+            return U256Codec.encode(changetype<u256>(value));
+        }
+
+        if (value instanceof u128) {
+            // store big-endian
+            const uval = changetype<u128>(value);
+            return uval.toUint8Array(true);
+        }
+
+        if (value instanceof i128) {
+            const ival = changetype<i128>(value);
+            return ival.toUint8Array(true);
+        }
+
+        if (value instanceof Address) {
+            return AddressCodec.encode(changetype<Address>(value));
+        }
+
+        // If nested map => handle in a custom branch (not shown here):
+        // if (value instanceof StorageMap<...>) { ... }
+
+        throw new Revert('encodeValue: Unsupported type');
+    }
+}

package/runtime/nested/storage/StorageSet.ts

@@ -0,0 +1,57 @@
+import { ICodec } from '../interfaces/ICodec';
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { encodePointerUnknownLength } from '../../math/abi';
+import { Blockchain } from '../../env';
+
+
+export class StorageSet<T> {
+    private readonly pointer: u16;
+    private readonly parentKey: Uint8Array;
+
+    private elementCodec: ICodec<T>;
+
+    constructor(pointer: u16, parentKey: Uint8Array, elementCodec: ICodec<T>) {
+        this.pointer = pointer;
+        this.parentKey = parentKey;
+        this.elementCodec = elementCodec;
+    }
+
+    public add(value: T): void {
+        const storageKey = this.getStorageKey(value);
+
+        // A 1-byte array with a single 0x01 is enough to mark presence
+        const flag = new Uint8Array(1);
+        flag[31] = 1;
+
+        Blockchain.setStorageAt(storageKey, flag);
+    }
+
+    public has(value: T): bool {
+        const storageKey = this.getStorageKey(value);
+        return Blockchain.hasStorageAt(storageKey);
+    }
+
+    public delete(value: T): bool {
+        const storageKey = this.getStorageKey(value);
+        if (!Blockchain.hasStorageAt(storageKey)) {
+            return false;
+        }
+
+        Blockchain.setStorageAt(storageKey, new Uint8Array(32));
+        return true;
+    }
+
+    @unsafe
+    public clear(): void {
+        throw new Error('clear() not implemented.');
+    }
+
+    private getStorageKey(value: T): Uint8Array {
+        const encoded = this.elementCodec.encode(value);
+        const writer = new BytesWriter(this.parentKey.length + encoded.length);
+        writer.writeBytes(this.parentKey);
+        writer.writeBytes(encoded);
+
+        return encodePointerUnknownLength(this.pointer, writer.getBuffer());
+    }
+}

package/runtime/plugins/Plugin.ts

@@ -0,0 +1,12 @@
+import { Calldata } from '../types';
+
+export class Plugin {
+    public onDeployment(_calldata: Calldata): void {
+    }
+
+    public onExecutionStarted(): void {
+    }
+
+    public onExecutionCompleted(): void {
+    }
+}

package/runtime/storage/arrays/StoredAddressArray.ts

@@ -35,7 +35,7 @@ export class StoredAddressArray {
     constructor(public pointer: u16, public subPointer: Uint8Array) {
         assert(
             subPointer.length <= 30,
-            `You must pass a 30 bytes sub-pointer. (AddressArray, got ${this.subPointer.length})`,
+            `You must pass a 30 bytes sub-pointer. (AddressArray, got ${subPointer.length})`,
         );
 
         // Construct base pointer as a 32-byte array

package/runtime/memory/FastUint8Array.ts

@@ -1,122 +0,0 @@
-import { Revert } from '../types/Revert';
-import { ArrayBuffer } from 'arraybuffer';
-
-export class FastUint8Array {
-    public length: i32;
-    private ptr: usize;
-
-    [key: number]: u8;
-
-    constructor(length: i32) {
-        if (length < 0) {
-            throw new Revert('Negative length in FastUint8Array constructor');
-        }
-
-        this.length = length;
-        this.ptr = __alloc(<usize>length);
-    }
-
-    public static fromUint8Array(arr: Uint8Array): FastUint8Array {
-        const buffer = new FastUint8Array(arr.length);
-        for (let i: u32 = 0; i < arr.length; i++) {
-            buffer[i] = arr[i];
-        }
-
-        return buffer;
-    }
-
-    toArrayBuffer(): ArrayBuffer {
-        const arr = new Uint8Array(this.length);
-        for (let i: u32 = 0; i < arr.length; i++) {
-            arr[i] = this[i];
-        }
-
-        return arr.buffer;
-    }
-
-    /**
-     * Fills the buffer with a specified byte value.
-     */
-    fill(value: u8): void {
-        memory.fill(this.ptr, value, <usize>this.length);
-    }
-
-    /**
-     * Copies bytes from another FastUint8Array into this one, starting at `destOffset`.
-     */
-    copyFrom(source: FastUint8Array, destOffset: i32 = 0): void {
-        if (destOffset < 0) {
-            throw new Revert(`Negative destOffset in copyFrom: ${destOffset}`);
-        }
-
-        let maxBytes = source.length;
-        const destRemaining = this.length - destOffset;
-        if (destRemaining < maxBytes) {
-            maxBytes = destRemaining;
-        }
-
-        if (maxBytes <= 0) return;
-
-        memory.copy(
-            this.ptr + <usize>destOffset,
-            source.ptr,
-            <usize>maxBytes,
-        );
-    }
-
-    free(): void {
-        if (this.ptr != 0) {
-            __free(this.ptr);
-            this.ptr = 0;
-            this.length = 0;
-        }
-    }
-
-    /**
-     * Safe read operator: buffer[i]
-     * Throws on out-of-bounds.
-     */
-    @operator('[]')
-    private __get(index: i32): u8 {
-        if (<u32>index >= <u32>this.length) {
-            throw new Revert('Index out of range in __get');
-        }
-        return load<u8>(this.ptr + <usize>index);
-    }
-
-    /**
-     * Safe write operator: buffer[i] = value
-     * Throws on out-of-bounds.
-     */
-    @operator('[]=')
-    private __set(index: i32, value: u8): void {
-        if (<u32>index >= <u32>this.length) {
-            throw new Revert('Index out of range in __set');
-        }
-        store<u8>(this.ptr + <usize>index, value);
-    }
-
-    /**
-     * Braces read operator: buffer{i}
-     * Now also throws on out-of-bounds for safety.
-     */
-    @operator('{}')
-    private __uget(index: i32): u8 {
-        if (<u32>index >= <u32>this.length) {
-            throw new Revert('Index out of range in __uget');
-        }
-        return load<u8>(this.ptr + <usize>index);
-    }
-
-    /**
-     * Braces write operator: buffer{i} = value
-     * Now also throws on out-of-bounds.
-     */
-    @operator('{}=')
-    private __uset(index: i32, value: u8): void {
-        if (<u32>index >= <u32>this.length) {
-            throw new Revert('Index out of range in __uset');
-        }
-        store<u8>(this.ptr + <usize>index, value);
-    }
-}