@btc-vision/btc-runtime 1.9.15 → 1.10.0

package/runtime/nested/codecs/VariableBytesCodec.ts

@@ -1,134 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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';
-import { EMPTY_BUFFER } from '../../math/bytes';
-
-/**
- * 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 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, EMPTY_BUFFER);
-        return true;
-    }
-
-    @unsafe
-    public clear(): void {
-        // Not implemented: we'd need key-tracking to remove them all
-        throw new Revert('clear() not implemented; no key-tracking logic here.');
-    }
-
-    private getStorageKey(k: K): Uint8Array {
-        const keyBytes = this.encodeValue<K>(k);
-
-        return encodePointerUnknownLength(this.pointer, keyBytes);
-    }
-
-    /**
-     * 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);
-    }
-
-    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}`);
-    }
-
-    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<...>) { ... }
-        // TODO
-
-        throw new Revert('encodeValue: Unsupported type');
-    }
-}

package/runtime/nested/storage/StorageSet.ts

@@ -1,60 +0,0 @@
-import { ICodec } from '../interfaces/ICodec';
-import { BytesWriter } from '../../buffer/BytesWriter';
-import { encodePointerUnknownLength } from '../../math/abi';
-import { Blockchain } from '../../env';
-import { Revert } from '../../types/Revert';
-
-const SLOT_BYTES: i32 = 32;
-const PRESENCE_BYTE: u8 = 1;
-
-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(SLOT_BYTES);
-        flag[31] = PRESENCE_BYTE;
-
-        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(SLOT_BYTES));
-        return true;
-    }
-
-    @unsafe
-    public clear(): void {
-        throw new Revert('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());
-    }
-}