@btc-vision/btc-runtime 1.5.1 → 1.5.2

package/package.json

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

package/runtime/buffer/BytesReader.ts

@@ -15,6 +15,7 @@ import {
     U64_BYTE_LENGTH,
     U8_BYTE_LENGTH,
 } from '../utils';
+import { sizeof } from 'builtins';
 
 @final
 export class BytesReader {
@@ -29,6 +30,76 @@ export class BytesReader {
         return this.buffer.byteLength;
     }
 
+    public read<T>(): T {
+        const id = idof<T>();
+
+        if (isBoolean<T>()) {
+            return this.readBoolean() as T;
+        } else if (isString<T>()) {
+            return this.readStringWithLength() as T;
+        } else if (isInteger<T>()) {
+            if (isSigned<T>()) {
+                const size = sizeof<T>();
+
+                switch (size) {
+                    case 8:
+                        return this.readU8() as T;
+                    case 16:
+                        return this.readI16() as T;
+                    case 32:
+                        return this.readI32() as T;
+                    case 64:
+                        return this.readI64() as T;
+                    default:
+                        throw new Error(`Invalid size ${size}`);
+                }
+            } else {
+                const size = sizeof<T>();
+
+                switch (size) {
+                    case 8:
+                        return this.readU8() as T;
+                    case 16:
+                        return this.readU16() as T;
+                    case 32:
+                        return this.readU32() as T;
+                    case 64:
+                        return this.readU64() as T;
+                    default:
+                        throw new Error(`Invalid size ${size}`);
+                }
+            }
+        } else if (id === idof<u256>()) {
+            return this.readU256() as T;
+        } else if (id === idof<u128>()) {
+            return this.readU128() as T;
+        } else if (id === idof<i128>()) {
+            return this.readI128() as T;
+        } else if (id === idof<Address>()) {
+            return this.readAddress() as T;
+        } else if (id === idof<Uint8Array>()) {
+            return this.readBytesWithLength() as T;
+        } else if (id === idof<string>()) {
+            return this.readStringWithLength() as T;
+        } else {
+            throw new Error(`Unsupported type ${id}`);
+        }
+    }
+
+    public readI16(): i16 {
+        this.verifyEnd(this.currentOffset + 2);
+        const value = this.buffer.getInt16(this.currentOffset, true);
+        this.currentOffset += 2;
+        return value;
+    }
+
+    public readI32(): i32 {
+        this.verifyEnd(this.currentOffset + 4);
+        const value = this.buffer.getInt32(this.currentOffset, true);
+        this.currentOffset += 4;
+        return value;
+    }
+
     public readU8(): u8 {
         this.verifyEnd(this.currentOffset + U8_BYTE_LENGTH);
         const value = this.buffer.getUint8(this.currentOffset);
@@ -169,7 +240,7 @@ export class BytesReader {
         return addr;
     }
 
-    // ------------------- Arrays ------------------- //
+// ------------------- Arrays ------------------- //
 
     /**
      * The AS writer does `writeU32(length)` for U256 arrays, so we read a u32.

package/runtime/buffer/BytesWriter.ts

@@ -30,6 +30,62 @@ export class BytesWriter {
         return this.buffer.byteLength;
     }
 
+    public write<T>(value: T): void {
+        if (isInteger<T>()) {
+            const size = sizeof<T>();
+            if (size === 1) {
+                this.writeU8(<u8>value);
+                return;
+            }
+
+            if (isSigned<T>()) {
+                switch (size) {
+                    case 2:
+                        this.writeI16(<i16>value);
+                        break;
+                    case 4:
+                        this.writeI32(<i32>value);
+                        break;
+                    case 8:
+                        this.writeI64(<i64>value);
+                        break;
+                    default:
+                        throw new Revert(`Unsupported integer size: ${size}`);
+                }
+            } else {
+                switch (size) {
+                    case 2:
+                        this.writeU16(<u16>value);
+                        break;
+                    case 4:
+                        this.writeU32(<u32>value);
+                        break;
+                    case 8:
+                        this.writeU64(<u64>value);
+                        break;
+                    default:
+                        throw new Revert(`Unsupported integer size: ${size}`);
+                }
+            }
+        } else if (isBoolean<T>()) {
+            this.writeBoolean(<boolean>value);
+        } else if (isString<T>()) {
+            this.writeStringWithLength(<string>value);
+        } else if (value instanceof Uint8Array) {
+            this.writeBytesWithLength(<Uint8Array>value);
+        } else if (value instanceof Address) {
+            this.writeAddress(<Address>value);
+        } else if (value instanceof u128) {
+            this.writeU128(<u128>value);
+        } else if (value instanceof u256) {
+            this.writeU256(<u256>value);
+        } else if (value instanceof i128) {
+            this.writeI128(<i128>value);
+        } else {
+            throw new Revert(`Unsupported type: ${typeof value}`);
+        }
+    }
+
     public writeU8(value: u8): void {
         this.allocSafe(U8_BYTE_LENGTH);
         this.buffer.setUint8(this.currentOffset, value);
@@ -64,6 +120,24 @@ export class BytesWriter {
         this.currentOffset += U64_BYTE_LENGTH;
     }
 
+    public writeI64(value: i64, be: boolean = true): void {
+        this.allocSafe(U64_BYTE_LENGTH);
+        this.buffer.setInt64(this.currentOffset, value, !be);
+        this.currentOffset += U64_BYTE_LENGTH;
+    }
+
+    public writeI32(value: i32, be: boolean = true): void {
+        this.allocSafe(U32_BYTE_LENGTH);
+        this.buffer.setInt32(this.currentOffset, value, !be);
+        this.currentOffset += U32_BYTE_LENGTH;
+    }
+
+    public writeI16(value: i16, be: boolean = true): void {
+        this.allocSafe(U16_BYTE_LENGTH);
+        this.buffer.setInt16(this.currentOffset, value, !be);
+        this.currentOffset += U16_BYTE_LENGTH;
+    }
+
     /**
      * Writes a 32-bit selector.
      * @param value

package/runtime/contracts/DeployableOP_20.ts

@@ -3,8 +3,6 @@ import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { ApproveEvent, BurnEvent, MintEvent, TransferEvent } from '../events/predefined';
 import { encodeSelector, Selector } from '../math/abi';
-import { AddressMemoryMap } from '../memory/AddressMemoryMap';
-import { MultiAddressMemoryMap } from '../memory/MultiAddressMemoryMap';
 import { StoredString } from '../storage/StoredString';
 import { StoredU256 } from '../storage/StoredU256';
 import { Address } from '../types/Address';
@@ -19,6 +17,8 @@ import { OP20InitParameters } from './interfaces/OP20InitParameters';
 import { OP_NET } from './OP_NET';
 import { sha256 } from '../env/global';
 import { EMPTY_POINTER } from '../math/bytes';
+import { MapOfMap } from '../memory/MapOfMap';
+import { AddressMemoryMap } from '../memory/AddressMemoryMap';
 
 const nonceMapPointer: u16 = Blockchain.nextPointer;
 const maxSupplyPointer: u16 = Blockchain.nextPointer;
@@ -29,7 +29,7 @@ const allowanceMapPointer: u16 = Blockchain.nextPointer;
 const balanceOfMapPointer: u16 = Blockchain.nextPointer;
 
 export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
-    protected readonly allowanceMap: MultiAddressMemoryMap;
+    protected readonly allowanceMap: MapOfMap<u256>;
     protected readonly balanceOfMap: AddressMemoryMap;
 
     protected readonly _maxSupply: StoredU256;
@@ -43,14 +43,15 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         super();
 
         // Initialize main storage structures
-        this.allowanceMap = new MultiAddressMemoryMap(allowanceMapPointer);
+        this.allowanceMap = new MapOfMap(allowanceMapPointer);
         this.balanceOfMap = new AddressMemoryMap(balanceOfMapPointer);
+        this._nonceMap = new AddressMemoryMap(nonceMapPointer);
+
         this._totalSupply = new StoredU256(totalSupplyPointer, EMPTY_POINTER);
         this._maxSupply = new StoredU256(maxSupplyPointer, EMPTY_POINTER);
         this._decimals = new StoredU256(decimalsPointer, EMPTY_POINTER);
         this._name = new StoredString(stringPointer, 0);
         this._symbol = new StoredString(stringPointer, 1);
-        this._nonceMap = new AddressMemoryMap(nonceMapPointer);
 
         if (params && this._maxSupply.value.isZero()) {
             this.instantiate(params, true);

package/runtime/env/BlockchainEnvironment.ts

@@ -23,6 +23,8 @@ import {
 } from './global';
 import { eqUint, MapUint8Array } from '../generic/MapUint8Array';
 import { EMPTY_BUFFER } from '../math/bytes';
+import { Plugin } from '../plugins/Plugin';
+import { Calldata } from '../types';
 
 export * from '../env/global';
 
@@ -38,6 +40,7 @@ export class BlockchainEnvironment {
 
     private storage: MapUint8Array = new MapUint8Array();
     private _selfContract: Potential<OP_NET> = null;
+    private _plugins: Plugin[] = [];
 
     private _block: Potential<Block> = null;
 
@@ -105,6 +108,40 @@ export class BlockchainEnvironment {
         return this._contractAddress as Address;
     }
 
+    public registerPlugin(plugin: Plugin): void {
+        this._plugins.push(plugin);
+    }
+
+    public onDeployment(calldata: Calldata): void {
+        for (let i: i32 = 0; i < this._plugins.length; i++) {
+            const plugin = this._plugins[i];
+
+            plugin.onDeployment(calldata);
+        }
+
+        this.contract.onDeployment(calldata);
+    }
+
+    public onExecutionStarted(): void {
+        for (let i: i32 = 0; i < this._plugins.length; i++) {
+            const plugin = this._plugins[i];
+
+            plugin.onExecutionStarted();
+        }
+
+        this.contract.onExecutionStarted();
+    }
+
+    public onExecutionCompleted(): void {
+        for (let i: i32 = 0; i < this._plugins.length; i++) {
+            const plugin = this._plugins[i];
+
+            plugin.onExecutionCompleted();
+        }
+
+        this.contract.onExecutionCompleted();
+    }
+
     public setEnvironmentVariables(data: Uint8Array): void {
         const reader: BytesReader = new BytesReader(data);
 

package/runtime/exports/index.ts

@@ -18,11 +18,11 @@ export function execute(calldataLength: u32): u32 {
     const calldata: Calldata = new BytesReader(Uint8Array.wrap(calldataBuffer));
     const selector: Selector = calldata.readSelector();
 
-    Blockchain.contract.onExecutionStarted();
+    Blockchain.onExecutionStarted();
 
     const result: BytesWriter = Blockchain.contract.execute(selector, calldata);
 
-    Blockchain.contract.onExecutionCompleted();
+    Blockchain.onExecutionCompleted();
 
     const resultBuffer = result.getBuffer().buffer;
     const resultLength = resultBuffer.byteLength;
@@ -43,9 +43,9 @@ export function onDeploy(calldataLength: u32): u32 {
 
     const calldata: Calldata = new BytesReader(Uint8Array.wrap(calldataBuffer));
 
-    Blockchain.contract.onExecutionStarted();
-    Blockchain.contract.onDeployment(calldata);
-    Blockchain.contract.onExecutionCompleted();
+    Blockchain.onExecutionStarted();
+    Blockchain.onDeployment(calldata);
+    Blockchain.onExecutionCompleted();
 
     return 0;
 }

package/runtime/index.ts

@@ -45,12 +45,18 @@ export * from './math/bytes';
 export * from './secp256k1/ECPoint';
 
 /** Memory */
-export * from './memory/AddressMemoryMap';
-export * from './memory/StringMemoryMap';
-export * from './memory/MultiStringMemoryMap';
-export * from './memory/KeyMerger';
-export * from './memory/MultiAddressMemoryMap';
-export * from './memory/Uint8ArrayMerger';
+export * from './memory/Nested';
+export * from './nested/PointerManager';
+export * from './nested/storage/StorageMap';
+export * from './nested/storage/StorageSet';
+
+/** Codecs */
+export * from './nested/codecs/U256Codec';
+export * from './nested/codecs/AddressCodec';
+export * from './nested/codecs/NumericCodec';
+export * from './nested/codecs/BooleanCodec';
+export * from './nested/codecs/StringCodec';
+export * from './nested/codecs/VariableBytesCodec';
 
 /** Storage */
 export * from './storage/StoredU256';
@@ -58,7 +64,6 @@ export * from './storage/StoredU64';
 export * from './storage/StoredString';
 export * from './storage/StoredAddress';
 export * from './storage/StoredBoolean';
-export * from './storage/Serializable';
 
 /** Arrays */
 export * from './storage/arrays/StoredAddressArray';
@@ -71,8 +76,6 @@ export * from './storage/arrays/StoredU64Array';
 export * from './storage/arrays/StoredU128Array';
 export * from './storage/arrays/StoredU256Array';
 
-export * from './memory/FastUint8Array';
-
 /** Shared libraries */
 export * from './shared-libraries/TransferHelper';
 export * from './shared-libraries/OP20Utils';

package/runtime/memory/{MultiAddressMemoryMap.ts → MapOfMap.ts}

@@ -1,10 +1,10 @@
-import { Uint8ArrayMerger } from './Uint8ArrayMerger';
 import { Address } from '../types/Address';
+import { Nested } from './Nested';
 
 @final
-export class MultiAddressMemoryMap extends Map<
+export class MapOfMap<T> extends Map<
     Address,
-    Uint8ArrayMerger
+    Nested<T>
 > {
     public pointer: u16;
 
@@ -17,14 +17,14 @@ export class MultiAddressMemoryMap extends Map<
     }
 
     @inline
-    public get(key: Address): Uint8ArrayMerger {
+    public get(key: Address): Nested<T> {
         this.createKeyMerger(key);
 
         return super.get(key);
     }
 
     @inline
-    public set(key: Address, value: Uint8ArrayMerger): this {
+    public set(key: Address, value: Nested<T>): this {
         this.createKeyMerger(key);
 
         return <this>super.set(key, value);
@@ -48,7 +48,7 @@ export class MultiAddressMemoryMap extends Map<
     @inline
     private createKeyMerger(key: Address): void {
         if (!super.has(key)) {
-            super.set(key, new Uint8ArrayMerger(key, this.pointer));
+            super.set(key, new Nested<T>(key, this.pointer));
         }
     }
 }

package/runtime/memory/Nested.ts

@@ -0,0 +1,113 @@
+import { Blockchain } from '../env';
+import { encodePointerUnknownLength } from '../math/abi';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { u256 } from '@btc-vision/as-bignum/assembly';
+import { Address } from '../types/Address';
+
+@final
+export class Nested<T> {
+    public parentKey: Uint8Array;
+
+    public pointer: u16;
+
+    constructor(
+        parent: Uint8Array,
+        pointer: u16,
+    ) {
+        this.pointer = pointer;
+
+        this.parentKey = parent;
+    }
+
+    public set(key: Uint8Array, value: T): this {
+        const keyHash: Uint8Array = this.getKeyHash(key);
+        Blockchain.setStorageAt(keyHash, this.from(value));
+
+        return this;
+    }
+
+    public get(key: Uint8Array): T {
+        const keyHash: Uint8Array = this.getKeyHash(key);
+
+        return this.toValue(Blockchain.getStorageAt(keyHash));
+    }
+
+    public has(key: Uint8Array): bool {
+        const mergedKey: Uint8Array = this.getKeyHash(key);
+
+        return Blockchain.hasStorageAt(mergedKey);
+    }
+
+    @unsafe
+    public delete(_key: Uint8Array): bool {
+        throw new Error('Method not implemented.');
+    }
+
+    @unsafe
+    public clear(): void {
+        throw new Error('Clear method not implemented.');
+    }
+
+    /**
+     * Converts raw bytes from storage into type T.
+     */
+    private toValue(value: Uint8Array): T {
+        // Check T's compile-time type ID
+        if (idof<T>() == idof<u256>()) {
+            // We know T is u256
+            return changetype<T>(u256.fromUint8ArrayBE(value));
+        } else if (idof<T>() == idof<Uint8Array>()) {
+            // We know T is Uint8Array
+            return changetype<T>(value);
+        } else if (idof<T>() == idof<Address>()) {
+            // We know T is Address
+            return changetype<T>(value);
+        } else if (isInteger<T>()) {
+            // For a simple integer, just pull out the first byte
+            return value[0] as T;
+        } else if (isString<T>()) {
+            // T is a string
+            return changetype<T>(String.UTF8.decode(value.buffer));
+        }
+
+        throw new Error('Unsupported type');
+    }
+
+    /**
+     * Converts type T into raw bytes for storage.
+     */
+    private from(value: T): Uint8Array {
+        if (idof<T>() == idof<u256>()) {
+            // Cast T to u256, then convert to bytes
+            return changetype<u256>(value).toUint8Array(true);
+        } else if (idof<T>() == idof<Uint8Array>()) {
+            // Just return it
+            return changetype<Uint8Array>(value);
+        } else if (idof<T>() == idof<Address>()) {
+            // Address is already bytes
+            return changetype<Uint8Array>(value);
+        } else if (isInteger<T>()) {
+            const writer = new BytesWriter(sizeof<T>());
+            writer.write<T>(value);
+            return writer.getBuffer();
+        } else if (isString<T>()) {
+            const str = changetype<string>(value);
+            return Uint8Array.wrap(String.UTF8.encode(str));
+        }
+
+        throw new Error('Unsupported type');
+    }
+
+    private getKeyHash(key: Uint8Array): Uint8Array {
+        const writer: BytesWriter = new BytesWriter(key.byteLength + this.parentKey.byteLength);
+
+        writer.writeBytes(this.parentKey);
+        writer.writeBytes(key);
+
+        return this.encodePointer(writer);
+    }
+
+    private encodePointer(writer: BytesWriter): Uint8Array {
+        return encodePointerUnknownLength(this.pointer, writer.getBuffer());
+    }
+}

package/runtime/nested/PointerManager.ts

@@ -0,0 +1,55 @@
+import { Blockchain } from '../env';
+import { Potential } from '../lang/Definitions';
+import { bigEndianAdd } from '../math/bytes';
+import { Plugin } from '../plugins/Plugin';
+
+/**
+ * A unique key in storage that holds the next free "offset" as a 256-bit counter.
+ * You can change this to any 32-byte constant you like.
+ */
+const ALLOCATOR_KEY = new Uint8Array(32);
+for (let i = 0; i < 32; i++) {
+    ALLOCATOR_KEY[i] = 0xff;
+}
+
+/**
+ * PointerManager: ensures we never collide while allocating variable-length data.
+ * - We store a global "offset" in ALLOCATOR_KEY (as a big-endian u256).
+ * - Each time we allocate N slots (N * 32 bytes), we do:
+ *      oldOffset = currentGlobalOffset
+ *      newOffset = oldOffset + N
+ *      store newOffset back
+ *      return oldOffset as the base pointer
+ */
+class _PointerManager extends Plugin {
+    private _cachedOffset: Potential<Uint8Array> = null;
+
+    private get cachedOffset(): Uint8Array {
+        if (!this._cachedOffset) {
+            this._cachedOffset = Blockchain.getStorageAt(ALLOCATOR_KEY);
+        }
+
+        return this._cachedOffset as Uint8Array;
+    }
+
+    /**
+     * Allocates `numSlots` (each 32 bytes). Returns a 32-byte pointer (u256 in big-endian).
+     *
+     * Each slot is conceptually:
+     *   slot0 = pointer + 0
+     *   slot1 = pointer + 1
+     *   ...
+     * and so forth in big-endian arithmetic.
+     */
+    public allocateSlots(numSlots: u64): Uint8Array {
+        this._cachedOffset = bigEndianAdd(this.cachedOffset, numSlots);
+
+        const val = this.cachedOffset;
+        Blockchain.setStorageAt(ALLOCATOR_KEY, val);
+
+        return val;
+    }
+}
+
+export const PointerManager = new _PointerManager();
+Blockchain.registerPlugin(PointerManager);

package/runtime/nested/codecs/AddressCodec.ts

@@ -0,0 +1,19 @@
+import { ICodec } from '../interfaces/ICodec';
+import { Address } from '../../types/Address';
+
+class _AddressCodec implements ICodec<Address> {
+    public encode(value: Address): Uint8Array {
+        return value;
+    }
+
+    public decode(buffer: Uint8Array): Address {
+        if (buffer.length == 0) {
+            return Address.zero();
+        }
+
+        return Address.fromUint8Array(buffer);
+    }
+}
+
+export const idOfAddressCodec = idof<_AddressCodec>();
+export const AddressCodec = new _AddressCodec();

package/runtime/nested/codecs/BooleanCodec.ts

@@ -0,0 +1,17 @@
+import { ICodec } from '../interfaces/ICodec';
+
+class _BooleanCodec implements ICodec<bool> {
+    public encode(value: bool): Uint8Array {
+        const out = new Uint8Array(1);
+        out[0] = value ? 1 : 0;
+        return out;
+    }
+
+    public decode(buffer: Uint8Array): bool {
+        if (buffer.length == 0) return false;
+        return buffer[0] == 1;
+    }
+}
+
+export const idOfBoolCodec = idof<_BooleanCodec>();
+export const BooleanCodec = new _BooleanCodec();

package/runtime/nested/codecs/Ids.ts

@@ -0,0 +1,10 @@
+import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
+import { Uint8Array } from 'typedarray';
+import { Address } from '../../types/Address';
+
+export const idOfU256 = idof<u256>();
+export const idOfU128 = idof<u128>();
+export const idOfI128 = idof<i128>();
+export const idOfUint8Array = idof<Uint8Array>();
+export const idOfString = idof<string>();
+export const idOfAddress = idof<Address>();

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>();
+            }
+        }
+    }
+}