@btc-vision/btc-runtime 1.5.1 → 1.5.3

package/README.md

@@ -31,13 +31,13 @@ execution while integrating deeply with Bitcoin's decentralized architecture.
 
 ### Features
 
-- **AssemblyScript and WebAssembly:** Efficient and high-performance contract execution using WebAssembly.
-- **Bitcoin Integration:** Direct interaction with Bitcoin L1, enabling the creation of decentralized applications that
-  operate on the Bitcoin network.
-- **Comprehensive Storage Management:** Flexible and secure storage management using primary pointers and sub-pointers,
-  ensuring data integrity through cryptographic proofs.
-- **Event Handling:** Sophisticated event system for contract state changes, allowing easy tracking and logging of
-  contract activities.
+-   **AssemblyScript and WebAssembly:** Efficient and high-performance contract execution using WebAssembly.
+-   **Bitcoin Integration:** Direct interaction with Bitcoin L1, enabling the creation of decentralized applications that
+    operate on the Bitcoin network.
+-   **Comprehensive Storage Management:** Flexible and secure storage management using primary pointers and sub-pointers,
+    ensuring data integrity through cryptographic proofs.
+-   **Event Handling:** Sophisticated event system for contract state changes, allowing easy tracking and logging of
+    contract activities.
 
 ## Installation
 
@@ -105,7 +105,7 @@ import {
     Map,
     OP20InitParameters,
     Selector,
-    AddressMap
+    AddressMap,
 } from '@btc-vision/btc-runtime/runtime';
 import { u128, u256 } from 'as-bignum/assembly';
 
@@ -142,7 +142,7 @@ export class MyToken extends DeployableOP_20 {
     }
 
     private airdrop(calldata: Calldata): BytesWriter {
-        this.onlyOwner(Blockchain.tx.sender);
+        this.onlyDeployer(Blockchain.tx.sender);
 
         const drops: AddressMap<u256> = calldata.readAddressValueTuple();
 
@@ -169,7 +169,7 @@ export class MyToken extends DeployableOP_20 {
     }
 
     private airdropWithAmount(calldata: Calldata): BytesWriter {
-        this.onlyOwner(Blockchain.tx.sender);
+        this.onlyDeployer(Blockchain.tx.sender);
 
         const amount: u256 = calldata.readU256();
         const addresses: Address[] = calldata.readAddressArray();
@@ -211,11 +211,11 @@ class ComplexData extends Serializable {
 
 For more detailed explanations on specific topics, refer to the individual documentation files:
 
-- [Blockchain.md](docs/Blockchain.md)
-- [Contract.md](docs/Contract.md)
-- [Events.md](docs/Events.md)
-- [Pointers.md](docs/Pointers.md)
-- [Storage.md](docs/Storage.md)
+-   [Blockchain.md](docs/Blockchain.md)
+-   [Contract.md](docs/Contract.md)
+-   [Events.md](docs/Events.md)
+-   [Pointers.md](docs/Pointers.md)
+-   [Storage.md](docs/Storage.md)
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@btc-vision/btc-runtime",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "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.
@@ -258,12 +329,12 @@ export class BytesReader {
     }
 
     public readTransactionInputs(): TransactionInput[] {
-        const length = this.readU8();
+        const length = this.readU16();
         const result = new Array<TransactionInput>(length);
 
         for (let i: u16 = 0; i < length; i++) {
             const txId = this.readBytes(32);
-            const outputIndex = this.readU8();
+            const outputIndex = this.readU16();
             const scriptSig = this.readBytesWithLength();
             result[i] = new TransactionInput(txId, outputIndex, scriptSig);
         }
@@ -272,11 +343,11 @@ export class BytesReader {
     }
 
     public readTransactionOutputs(): TransactionOutput[] {
-        const length = this.readU8();
+        const length = this.readU16();
         const result = new Array<TransactionOutput>(length);
 
         for (let i: u16 = 0; i < length; i++) {
-            const index = this.readU8();
+            const index = this.readU16();
             const scriptPubKey = this.readStringWithLength();
             const value = this.readU64();
             result[i] = new TransactionOutput(index, scriptPubKey, value);

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,22 +3,22 @@ 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';
 import { Revert } from '../types/Revert';
 import { SafeMath } from '../types/SafeMath';
 
+import { sha256 } from '../env/global';
+import { EMPTY_POINTER } from '../math/bytes';
+import { AddressMemoryMap } from '../memory/AddressMemoryMap';
+import { MapOfMap } from '../memory/MapOfMap';
 import { ApproveStr, TransferFromStr, TransferStr } from '../shared-libraries/TransferHelper';
 import { Calldata } from '../types';
 import { ADDRESS_BYTE_LENGTH, BOOLEAN_BYTE_LENGTH, U256_BYTE_LENGTH } from '../utils';
 import { IOP_20 } from './interfaces/IOP_20';
 import { OP20InitParameters } from './interfaces/OP20InitParameters';
 import { OP_NET } from './OP_NET';
-import { sha256 } from '../env/global';
-import { EMPTY_POINTER } from '../math/bytes';
 
 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);
@@ -83,12 +84,15 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         return this._symbol.value;
     }
 
-    public instantiate(params: OP20InitParameters, skipOwnerVerification: boolean = false): void {
+    public instantiate(
+        params: OP20InitParameters,
+        skipDeployerVerification: boolean = false,
+    ): void {
         if (!this._maxSupply.value.isZero()) {
             throw new Revert('Already initialized');
         }
 
-        if (!skipOwnerVerification) this.onlyDeployer(Blockchain.tx.sender);
+        if (!skipDeployerVerification) this.onlyDeployer(Blockchain.tx.sender);
 
         if (params.decimals > 32) {
             throw new Revert('Decimals can not be more than 32');
@@ -445,8 +449,8 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         this.emitEvent(approveEvent);
     }
 
-    protected createMintEvent(owner: Address, value: u256): void {
-        const mintEvent = new MintEvent(owner, value);
+    protected createMintEvent(recipient: Address, value: u256): void {
+        const mintEvent = new MintEvent(recipient, value);
         this.emitEvent(mintEvent);
     }
 

package/runtime/contracts/OP_NET.ts

@@ -17,14 +17,11 @@ export class OP_NET implements IBTC {
         return Blockchain.contractDeployer;
     }
 
-    public onDeployment(_calldata: Calldata): void {
-    }
+    public onDeployment(_calldata: Calldata): void {}
 
-    public onExecutionStarted(): void {
-    }
+    public onExecutionStarted(): void {}
 
-    public onExecutionCompleted(): void {
-    }
+    public onExecutionCompleted(): void {}
 
     public execute(method: Selector, _calldata: Calldata): BytesWriter {
         let response: BytesWriter;
@@ -55,7 +52,7 @@ export class OP_NET implements IBTC {
 
     protected onlyDeployer(caller: Address): void {
         if (this.contractDeployer !== caller) {
-            throw new Revert('Only owner can call this method');
+            throw new Revert('Only deployer can call this method');
         }
     }
 }

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/env/classes/UTXO.ts

@@ -2,7 +2,7 @@
 export class TransactionInput {
     public constructor(
         public readonly txId: Uint8Array,
-        public readonly outputIndex: u8,
+        public readonly outputIndex: u16,
         public readonly scriptSig: Uint8Array,
     ) {
     }
@@ -11,7 +11,7 @@ export class TransactionInput {
 @final
 export class TransactionOutput {
     public constructor(
-        public readonly index: u8,
+        public readonly index: u16,
         public readonly to: string,
         public readonly value: u64,
     ) {

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