@btc-vision/btc-runtime 1.1.11 → 1.2.1

package/package.json

@@ -1,10 +1,12 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.1.11",
+    "version": "1.2.1",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
+    "scripts": {
+        "build": "cross-env node scripts/asc tests/tests.ts"
+    },
     "types": "btc/index.ts",
-    "scripts": {},
     "keywords": [
         "bitcoin",
         "smart",
@@ -17,9 +19,12 @@
     "author": "BlobMaster41",
     "license": "MIT",
     "devDependencies": {
+        "@types/mocha": "^10.0.8",
         "@types/node": "^22.5.5",
-        "assemblyscript": "^0.27.25",
-        "prettier": "^3.2.5"
+        "assemblyscript": "^0.27.30",
+        "cross-env": "^7.0.3",
+        "ts-mocha": "^10.0.0",
+        "fs-extra": "^11.2.0"
     },
     "repository": {
         "type": "git",
@@ -32,10 +37,11 @@
         "runtime/*.ts",
         "runtime/**/*.ts",
         "!**/*.js.map",
-        "!**/*.tsbuildinfo"
+        "!**/*.tsbuildinfo",
+        "test/*.ts"
     ],
     "dependencies": {
-        "@assemblyscript/loader": "^0.27.25",
+        "@assemblyscript/loader": "^0.27.30",
         "@eslint/js": "^9.10.0",
         "as-bignum": "^0.3.0",
         "gulplog": "^2.2.0",

package/runtime/buffer/BytesReader.ts

@@ -3,6 +3,8 @@ import { Selector } from '../math/abi';
 import { u256 } from 'as-bignum/assembly';
 import { Revert } from '../types/Revert';
 import { Map } from '../generic/Map';
+import { TransactionInput, TransactionOutput } from '../env/classes/UTXO';
+import { StaticArray } from 'staticarray';
 
 @final
 export class BytesReader {
@@ -106,6 +108,36 @@ export class BytesReader {
         return String.UTF8.decode(bytes.buffer);
     }
 
+    public readTransactionInputs(): StaticArray<TransactionInput> {
+        const length = this.readU8();
+        const result = new StaticArray<TransactionInput>(length);
+
+        for (let i: u16 = 0; i < length; i++) {
+            const txId = this.readBytes(32);
+            const outputIndex = this.readU8();
+            const scriptSig = this.readBytesWithLength();
+
+            result[i] = new TransactionInput(txId, outputIndex, scriptSig);
+        }
+
+        return result;
+    }
+
+    public readTransactionOutputs(): StaticArray<TransactionOutput> {
+        const length = this.readU8();
+        const result = new StaticArray<TransactionOutput>(length);
+
+        for (let i: u16 = 0; i < length; i++) {
+            const index = this.readU8();
+            const scriptPubKey = this.readBytesWithLength();
+            const value = this.readU64();
+
+            result[i] = new TransactionOutput(index, scriptPubKey, value);
+        }
+
+        return result;
+    }
+
     public readTuple(): u256[] {
         const length = this.readU32();
         const result: u256[] = new Array<u256>(length);

package/runtime/buffer/BytesWriter.ts

@@ -11,10 +11,11 @@ export class BytesWriter {
     private currentOffset: u32 = 0;
     private buffer: DataView;
 
-    constructor(length: i32) {
-        const arrayBuffer = new ArrayBuffer(length);
+    private readonly typedArray: Uint8Array;
 
-        this.buffer = new DataView(arrayBuffer);
+    constructor(length: i32) {
+        const typedArray = (this.typedArray = new Uint8Array(length));
+        this.buffer = new DataView(typedArray.buffer);
     }
 
     public bufferLength(): u32 {
@@ -63,12 +64,7 @@ export class BytesWriter {
     }
 
     public writeU256(value: u256): void {
-        this.allocSafe(32);
-
-        const bytes = value.toUint8Array(true);
-        for (let i: i32 = 0; i < 32; i++) {
-            this.writeU8(bytes[i] || 0);
-        }
+        this.writeBytesU8Array(value.toUint8Array());
     }
 
     public writeTuple(value: u256[]): void {
@@ -81,14 +77,11 @@ export class BytesWriter {
     }
 
     public writeBytes(value: Uint8Array): void {
-        this.allocSafe(value.length);
-
-        for (let i = 0; i < value.length; i++) {
-            this.writeU8(value[i]);
-        }
+        this.writeBytesU8Array(value);
     }
 
-    public writeBytesU8Array(value: u8[]): void {
+    @inline
+    public writeBytesU8Array(value: Uint8Array): void {
         this.allocSafe(value.length);
 
         for (let i = 0; i < value.length; i++) {
@@ -196,7 +189,7 @@ export class BytesWriter {
     }
 
     public getBuffer(): Uint8Array {
-        return Uint8Array.wrap(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+        return this.typedArray;
     }
 
     public toBytesReader(): BytesReader {

package/runtime/contracts/DeployableOP_20.ts

@@ -11,10 +11,11 @@ import { StoredU256 } from '../storage/StoredU256';
 import { Address } from '../types/Address';
 import { Revert } from '../types/Revert';
 import { SafeMath } from '../types/SafeMath';
-import { Calldata } from '../universal/ABIRegistry';
+
 import { IOP_20 } from './interfaces/IOP_20';
 import { OP20InitParameters } from './interfaces/OP20InitParameters';
 import { OP_NET } from './OP_NET';
+import { Calldata } from '../types';
 
 const maxSupplyPointer: u16 = Blockchain.nextPointer;
 const decimalsPointer: u16 = Blockchain.nextPointer;
@@ -94,7 +95,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
             throw new Revert('Already initialized');
         }
 
-        if (!skipOwnerVerification) this.onlyOwner(Blockchain.msgSender);
+        if (!skipOwnerVerification) this.onlyOwner(Blockchain.tx.sender);
 
         if (params.decimals > 32) {
             throw new Revert('Decimals can not be more than 32');
@@ -118,7 +119,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
 
     public approve(callData: Calldata): BytesWriter {
         // Define the owner and spender
-        const owner = Blockchain.msgSender;
+        const owner = Blockchain.tx.sender;
         const spender: Address = callData.readAddress();
         const value = callData.readU256();
 
@@ -180,28 +181,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         return response;
     }
 
-    public callMethod(method: Selector, calldata: Calldata): BytesWriter {
-        switch (method) {
-            case encodeSelector('allowance'):
-                return this.allowance(calldata);
-            case encodeSelector('approve'):
-                return this.approve(calldata);
-            case encodeSelector('balanceOf'):
-                return this.balanceOf(calldata);
-            case encodeSelector('burn'):
-                return this.burn(calldata);
-            case encodeSelector('mint'):
-                return this.mint(calldata);
-            case encodeSelector('transfer'):
-                return this.transfer(calldata);
-            case encodeSelector('transferFrom'):
-                return this.transferFrom(calldata);
-            default:
-                return super.callMethod(method, calldata);
-        }
-    }
-
-    public callView(method: Selector): BytesWriter {
+    public execute(method: Selector, calldata: Calldata): BytesWriter {
         let response: BytesWriter;
 
         switch (method) {
@@ -225,8 +205,22 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
                 response = new BytesWriter(32);
                 response.writeU256(this.maxSupply);
                 break;
+            case encodeSelector('allowance'):
+                return this.allowance(calldata);
+            case encodeSelector('approve'):
+                return this.approve(calldata);
+            case encodeSelector('balanceOf'):
+                return this.balanceOf(calldata);
+            case encodeSelector('burn'):
+                return this.burn(calldata);
+            case encodeSelector('mint'):
+                return this.mint(calldata);
+            case encodeSelector('transfer'):
+                return this.transfer(calldata);
+            case encodeSelector('transferFrom'):
+                return this.transferFrom(calldata);
             default:
-                return super.callView(method);
+                return super.execute(method, calldata);
         }
 
         return response;
@@ -264,16 +258,16 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
             throw new Revert(`No tokens`);
         }
 
-        if (onlyOwner) this.onlyOwner(Blockchain.msgSender);
+        if (onlyOwner) this.onlyOwner(Blockchain.tx.sender);
 
         if (this._totalSupply.value < value) throw new Revert(`Insufficient total supply.`);
-        if (!this.balanceOfMap.has(Blockchain.msgSender)) throw new Revert('No balance');
+        if (!this.balanceOfMap.has(Blockchain.tx.sender)) throw new Revert('No balance');
 
-        const balance: u256 = this.balanceOfMap.get(Blockchain.msgSender);
+        const balance: u256 = this.balanceOfMap.get(Blockchain.tx.sender);
         if (balance < value) throw new Revert(`Insufficient balance`);
 
         const newBalance: u256 = SafeMath.sub(balance, value);
-        this.balanceOfMap.set(Blockchain.msgSender, newBalance);
+        this.balanceOfMap.set(Blockchain.tx.sender, newBalance);
 
         // @ts-expect-error TODO: Fix the typing because this is valid assembly-script syntax
         this._totalSupply -= value;
@@ -283,7 +277,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     protected _mint(to: Address, value: u256, onlyOwner: boolean = true): boolean {
-        if (onlyOwner) this.onlyOwner(Blockchain.msgSender);
+        if (onlyOwner) this.onlyOwner(Blockchain.tx.sender);
 
         if (!this.balanceOfMap.has(to)) {
             this.balanceOfMap.set(to, value);
@@ -304,7 +298,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     protected _transfer(to: string, value: u256): boolean {
-        const sender = Blockchain.msgSender;
+        const sender = Blockchain.tx.sender;
 
         if (!this.balanceOfMap.has(sender)) throw new Revert();
         if (this.isSelf(sender)) throw new Revert('Can not transfer from self account');
@@ -359,7 +353,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
             throw new Revert('Cannot transfer to or from dead address');
         }
 
-        this._spendAllowance(from, Blockchain.msgSender, value);
+        this._spendAllowance(from, Blockchain.tx.sender, value);
         this._unsafeTransferFrom(from, to, value);
 
         return true;

package/runtime/contracts/OP_NET.ts

@@ -1,19 +1,13 @@
 import { IBTC } from '../interfaces/IBTC';
 import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { Blockchain } from '../env';
-import { Calldata } from '../universal/ABIRegistry';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { encodeSelector, Selector } from '../math/abi';
 import { Revert } from '../types/Revert';
 import { MAX_EVENT_DATA_SIZE, NetEvent } from '../events/NetEvent';
-import { StoredBoolean } from '../storage/StoredBoolean';
+import { Calldata } from '../types';
 
 export class OP_NET implements IBTC {
-    protected readonly instantiated: StoredBoolean = new StoredBoolean(
-        Blockchain.nextPointer,
-        false,
-    );
-
     public get address(): string {
         return Blockchain.contractAddress;
     }
@@ -22,24 +16,9 @@ export class OP_NET implements IBTC {
         return Blockchain.owner;
     }
 
-    public get isInstantiated(): bool {
-        return this.instantiated.value;
-    }
-
-    public onInstantiated(): void {
-        if (!this.isInstantiated) {
-            this.instantiated.value = true;
-        }
-    }
-
-    public callMethod(method: Selector, _calldata: Calldata): BytesWriter {
-        switch (method) {
-            default:
-                throw new Revert('Method not found');
-        }
-    }
+    public onDeployment(_calldata: Calldata): void {}
 
-    public callView(method: Selector): BytesWriter {
+    public execute(method: Selector, _calldata: Calldata): BytesWriter {
         let response: BytesWriter;
 
         switch (method) {
@@ -63,7 +42,7 @@ export class OP_NET implements IBTC {
             throw new Error('Event data length exceeds maximum length.');
         }
 
-        Blockchain.addEvent(event);
+        Blockchain.emit(event);
     }
 
     protected isSelf(address: Address): boolean {

package/runtime/env/{BTCEnvironment.ts → BlockchainEnvironment.ts}

@@ -1,12 +1,11 @@
-import { Address, ADDRESS_BYTE_LENGTH, PotentialAddress } from '../types/Address';
+import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { MemorySlotData } from '../memory/MemorySlot';
 import { u256 } from 'as-bignum/assembly';
-import { ABIRegistry } from '../universal/ABIRegistry';
 import { BytesReader } from '../buffer/BytesReader';
 import { encodePointerHash } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';
-import { MAX_EVENTS, NetEvent } from '../events/NetEvent';
+import { NetEvent } from '../events/NetEvent';
 import { Potential } from '../lang/Definitions';
 import { OP_NET } from '../contracts/OP_NET';
 import { PointerStorage } from '../types';
@@ -14,6 +13,7 @@ import {
     callContract,
     deploy,
     deployFromAddress,
+    emit,
     encodeAddress,
     loadPointer,
     log,
@@ -21,44 +21,44 @@ import {
 } from './global';
 import { DeployContractResponse } from '../interfaces/DeployContractResponse';
 import { MapU256 } from '../generic/MapU256';
+import { Block } from './classes/Block';
+import { Transaction } from './classes/Transaction';
 
 export * from '../env/global';
 
+export function runtimeError(msg: string): Error {
+    return new Error(`RuntimeException: ${msg}`);
+}
+
 @final
 export class BlockchainEnvironment {
     private static readonly MAX_U16: u16 = 65535;
-    private static readonly runtimeException: string = 'RuntimeException';
+
     public readonly DEAD_ADDRESS: Address = 'bc1dead';
-    private storage: PointerStorage = new MapU256();
-    private events: NetEvent[] = [];
-    private currentBlock: u256 = u256.Zero;
 
+    private storage: PointerStorage = new MapU256();
     private _selfContract: Potential<OP_NET> = null;
 
-    private _txOrigin: PotentialAddress = null;
+    private _block: Potential<Block> = null;
 
-    public get txOrigin(): Address {
-        if (!this._txOrigin) {
-            throw this.error('Callee is required');
+    @inline
+    public get block(): Block {
+        if (!this._block) {
+            throw this.error('Block is required');
         }
 
-        return this._txOrigin as Address;
+        return this._block as Block;
     }
 
-    private _msgSender: PotentialAddress = null;
+    private _tx: Potential<Transaction> = null;
 
-    public get msgSender(): Address {
-        if (!this._msgSender) {
-            throw this.error('Caller is required');
+    @inline
+    public get tx(): Transaction {
+        if (!this._tx) {
+            throw this.error('Transaction is required');
         }
 
-        return this._msgSender as Address;
-    }
-
-    private _timestamp: u64 = 0;
-
-    public get timestamp(): u64 {
-        return this._timestamp;
+        return this._tx as Transaction;
     }
 
     private _contract: Potential<() => OP_NET> = null;
@@ -105,25 +105,24 @@ export class BlockchainEnvironment {
         return this._contractAddress as Address;
     }
 
-    public get blockNumber(): u256 {
-        return this.currentBlock;
-    }
-
-    public get blockNumberU64(): u64 {
-        return this.currentBlock.toU64();
-    }
-
     public setEnvironment(data: Uint8Array): void {
         const reader: BytesReader = new BytesReader(data);
 
-        this._msgSender = reader.readAddress();
-        this._txOrigin = reader.readAddress(); // "leftmost thing in the call chain"
-        this.currentBlock = reader.readU256();
+        this._tx = new Transaction(
+            reader.readAddress(),
+            reader.readAddress(),
+            reader.readBytes(32),
+        );
+
+        const currentBlock = reader.readU256();
 
         this._owner = reader.readAddress();
         this._contractAddress = reader.readAddress();
 
-        this._timestamp = reader.readU64();
+        const medianTimestamp = reader.readU64();
+        const safeRnd64 = reader.readU64();
+
+        this._block = new Block(currentBlock, medianTimestamp, safeRnd64);
 
         this.createContractIfNotExists();
     }
@@ -154,32 +153,14 @@ export class BlockchainEnvironment {
         log(buffer);
     }
 
-    public addEvent(event: NetEvent): void {
-        if (this.events.length >= i32(MAX_EVENTS)) {
-            throw this.error(`Too many events in the same transaction.`);
-        }
+    public emit(event: NetEvent): void {
+        const data = event.getEventData();
+        const buffer = new BytesWriter(event.eventType.length + 6 + data.byteLength);
 
-        this.events.push(event);
-    }
-
-    public getEvents(): Uint8Array {
-        const eventLength: u16 = u16(this.events.length);
-        if (eventLength > MAX_EVENTS) {
-            throw this.error('Too many events');
-        }
-
-        const buffer: BytesWriter = new BytesWriter(this.getEventSize());
-        buffer.writeU16(eventLength);
-
-        for (let i: u8 = 0; i < eventLength; i++) {
-            const event: NetEvent = this.events[i];
-
-            buffer.writeStringWithLength(event.eventType);
-            buffer.writeU64(0); //event.getEventDataSelector()
-            buffer.writeBytesWithLength(event.getEventData());
-        }
+        buffer.writeStringWithLength(event.eventType);
+        buffer.writeBytesWithLength(data);
 
-        return buffer.getBuffer();
+        emit(buffer.getBuffer());
     }
 
     public encodeVirtualAddress(virtualAddress: Uint8Array): Address {
@@ -260,21 +241,6 @@ export class BlockchainEnvironment {
         this._internalSetStorageAt(pointerHash, value);
     }
 
-    public getMethodSelectors(): Uint8Array {
-        return ABIRegistry.getMethodSelectors();
-    }
-
-    private getEventSize(): u32 {
-        let size: u32 = 2;
-
-        for (let i: u32 = 0; i < <u32>this.events.length; i++) {
-            const event: NetEvent = this.events[i];
-            size += 2 + event.eventType.length + 8 + event.length + 4;
-        }
-
-        return size;
-    }
-
     private createContractIfNotExists(): void {
         if (!this._contract) {
             throw this.error('Contract is required');
@@ -286,7 +252,7 @@ export class BlockchainEnvironment {
     }
 
     private error(msg: string): Error {
-        return new Error(`${BlockchainEnvironment.runtimeException}: ${msg}`);
+        return runtimeError(msg);
     }
 
     private _internalSetStorageAt(pointerHash: u256, value: MemorySlotData<u256>): void {

package/runtime/env/classes/Block.ts

@@ -0,0 +1,18 @@
+import { u256 } from 'as-bignum/assembly';
+
+@final
+export class Block {
+    private readonly u64BlockNumber: u64;
+
+    public constructor(
+        public readonly number: u256,
+        public readonly medianTimestamp: u64,
+        public readonly safeRnd64: u64,
+    ) {
+        this.u64BlockNumber = number.toU64();
+    }
+
+    public get numberU64(): u64 {
+        return this.u64BlockNumber;
+    }
+}

package/runtime/env/classes/Transaction.ts

@@ -0,0 +1,47 @@
+import { Address } from '../../types/Address';
+import { TransactionInput, TransactionOutput } from './UTXO';
+import { Potential } from '../../lang/Definitions';
+import { StaticArray } from 'staticarray';
+import { BytesReader } from '../../buffer/BytesReader';
+import { inputs, outputs } from '../global';
+
+@final
+export class Transaction {
+    public constructor(
+        public readonly sender: Address, // "immediate caller"
+        public readonly origin: Address, // "leftmost thing in the call chain"
+        public readonly id: Uint8Array,
+    ) {}
+
+    private _inputs: Potential<StaticArray<TransactionInput>> = null;
+
+    public get inputs(): StaticArray<TransactionInput> {
+        if (!this._inputs) {
+            this._inputs = this.loadInputs();
+        }
+
+        return this._inputs;
+    }
+
+    private _outputs: Potential<StaticArray<TransactionOutput>> = null;
+
+    public get outputs(): StaticArray<TransactionOutput> {
+        if (!this._outputs) {
+            this._outputs = this.loadOutputs();
+        }
+
+        return this._outputs;
+    }
+
+    private loadInputs(): StaticArray<TransactionInput> {
+        const buffer = new BytesReader(inputs());
+
+        return buffer.readTransactionInputs();
+    }
+
+    private loadOutputs(): StaticArray<TransactionOutput> {
+        const buffer = new BytesReader(outputs());
+
+        return buffer.readTransactionOutputs();
+    }
+}

package/runtime/env/classes/UTXO.ts

@@ -0,0 +1,17 @@
+@final
+export class TransactionInput {
+    public constructor(
+        public readonly txId: Uint8Array,
+        public readonly outputIndex: u8,
+        public readonly scriptSig: Uint8Array,
+    ) {}
+}
+
+@final
+export class TransactionOutput {
+    public constructor(
+        public readonly index: u8,
+        public readonly scriptPubKey: Uint8Array,
+        public readonly value: u64,
+    ) {}
+}

package/runtime/env/global.ts

@@ -22,11 +22,26 @@ export declare function callContract(data: Uint8Array): Uint8Array;
 @external('env', 'log')
 export declare function log(data: Uint8Array): void;
 
+// @ts-ignore
+@external('env', 'emit')
+export declare function emit(data: Uint8Array): void;
+
 // @ts-ignore
 @external('env', 'encodeAddress')
 export declare function encodeAddress(data: Uint8Array): Uint8Array;
 
-
 // @ts-ignore
 @external('env', 'sha256')
 export declare function sha256(data: Uint8Array): Uint8Array;
+
+// @ts-ignore
+@external('env', 'ripemd160')
+export declare function ripemd160(data: Uint8Array): Uint8Array;
+
+// @ts-ignore
+@external('env', 'inputs')
+export declare function inputs(): Uint8Array;
+
+// @ts-ignore
+@external('env', 'outputs')
+export declare function outputs(): Uint8Array;

package/runtime/env/index.ts

@@ -1,3 +1,3 @@
-import { BlockchainEnvironment } from './BTCEnvironment';
+import { BlockchainEnvironment } from './BlockchainEnvironment';
 
 export const Blockchain: BlockchainEnvironment = new BlockchainEnvironment();

package/runtime/events/NetEvent.ts

@@ -2,7 +2,6 @@ import { BytesWriter } from '../buffer/BytesWriter';
 import { Revert } from '../types/Revert';
 
 export const MAX_EVENT_DATA_SIZE: u32 = 352; // 352 bytes max per event.
-export const MAX_EVENTS: u16 = 1000; // 1000 events max per transactions.
 
 export abstract class NetEvent {
     private readonly buffer: Uint8Array;

package/runtime/events/predefined/MintEvent.ts

@@ -7,6 +7,7 @@ import { Address, ADDRESS_BYTE_LENGTH } from '../../types/Address';
 export class MintEvent extends NetEvent {
     constructor(address: Address, amount: u256) {
         const data: BytesWriter = new BytesWriter(32 + ADDRESS_BYTE_LENGTH);
+
         data.writeAddress(address);
         data.writeU256(amount);
 

package/runtime/exports/index.ts

@@ -1,27 +1,21 @@
-import { Calldata } from '../universal/ABIRegistry';
 import { Blockchain } from '../env';
-import { Selector } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { BytesReader } from '../buffer/BytesReader';
+import { Selector } from '../math/abi';
+import { Calldata } from '../types';
 
-export function readMethod(method: Selector, data: Uint8Array): Uint8Array {
+export function execute(data: Uint8Array): Uint8Array {
     const calldata: Calldata = new BytesReader(data);
-    const result: BytesWriter = Blockchain.contract.callMethod(method, calldata);
+    const selector: Selector = calldata.readSelector();
+    const result: BytesWriter = Blockchain.contract.execute(selector, calldata);
 
     return result.getBuffer();
 }
 
-export function readView(method: Selector): Uint8Array {
-    const result: BytesWriter = Blockchain.contract.callView(method);
-    return result.getBuffer();
-}
-
-export function getEvents(): Uint8Array {
-    return Blockchain.getEvents();
-}
+export function onDeploy(data: Uint8Array): void {
+    const calldata: Calldata = new BytesReader(data);
 
-export function getMethodABI(): Uint8Array {
-    return Blockchain.getMethodSelectors();
+    Blockchain.contract.onDeployment(calldata);
 }
 
 export function setEnvironment(data: Uint8Array): void {

package/runtime/index.ts

@@ -19,9 +19,15 @@ export * from './interfaces/DeployContractResponse';
 export * from './events/NetEvent';
 export * from './events/predefined';
 
+/** Env */
+export * from './env/classes/UTXO';
+export * from './env/classes/Transaction';
+export * from './env/classes/Block';
+
 /** Types */
 export * from './generic/Map';
 export * from './interfaces/IBTC';
+export * from './types';
 
 /** Definitions */
 export * from './lang/Definitions';
@@ -49,9 +55,10 @@ export * from './storage/StoredString';
 export * from './storage/StoredBoolean';
 export * from './storage/Serializable';
 
-/** Universal */
-export * from './universal/ABIRegistry';
-
 /** Shared libraries */
 export * from './shared-libraries/TransferHelper';
 export * from './shared-libraries/OP20Utils';
+
+/** Utils */
+export * from './utils/hex';
+export * from './utils/box';

package/runtime/tests/assert.ts

@@ -0,0 +1,8 @@
+export function assert(condition: boolean, e: string): void {
+  if (!condition) throw new Error(e);
+}
+
+export function assertEq<T>(a: T, b: T): void {
+  assert(a === b, "expected " + a.toString() + " to equal " + b.toString());
+}
+

package/runtime/tests/env.ts

@@ -0,0 +1,7 @@
+// @ts-ignore
+@external("env", "logStatic")
+export declare function __logStatic(ptr: ArrayBuffer): void;
+
+export function log(v: string): void {
+  return __logStatic(String.UTF8.encode(v));
+}

package/runtime/tests/tests.ts

@@ -0,0 +1,25 @@
+import { BytesWriter } from "../buffer/BytesWriter";
+import { u256 } from "as-bignum/assembly";
+import { Blockchain } from "../env";
+import { Box } from "../utils/box";
+import { log } from "./env";
+import { assertEq } from "./assert";
+
+export function test_encode(): void {
+  const writer = new BytesWriter(64);
+  writer.writeU256(u256.from(10));
+  writer.writeU256(u256.from(20));
+  const buffer = writer.getBuffer().buffer;
+  assertEq(Box.from(buffer).toHexString(), "0x0a000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000");
+}
+
+export function test_log(): void {
+  Blockchain.log("test logging test: OK!");
+}
+
+export function test_writeStringWithLength(): void {
+  const s = 'test write';
+  const writer = new BytesWriter(s.length + 2);
+  writer.writeStringWithLength(s);
+  assertEq(Box.from(writer.getBuffer().buffer).toHexString(), "0x0a0074657374207772697465");
+}

package/runtime/types/SafeMath.ts

@@ -35,8 +35,8 @@ export class SafeMath {
             throw new Error('SafeMath: modulo by zero');
         }
 
-        let divResult = SafeMath.div(a, b);
-        let product = SafeMath.mul(divResult, b);
+        const divResult = SafeMath.div(a, b);
+        const product = SafeMath.mul(divResult, b);
         return SafeMath.sub(a, product);
     }
 
@@ -121,16 +121,16 @@ export class SafeMath {
         if (u256.gt(y, u256.fromU32(3))) {
             let z = y;
 
-            let u246_2 = u256.fromU32(2);
+            const u246_2 = u256.fromU32(2);
 
-            let d = SafeMath.div(y, u246_2);
+            const d = SafeMath.div(y, u246_2);
             let x = SafeMath.add(d, u256.One);
 
             while (u256.lt(x, z)) {
                 z = x;
 
-                let u = SafeMath.div(y, x);
-                let y2 = u256.add(u, x);
+                const u = SafeMath.div(y, x);
+                const y2 = u256.add(u, x);
 
                 x = SafeMath.div(y2, u246_2);
             }
@@ -150,8 +150,8 @@ export class SafeMath {
             return value.clone();
         }
 
-        let totalBits = 256;
-        let bitsPerSegment = 64;
+        const totalBits = 256;
+        const bitsPerSegment = 64;
 
         // Normalize shift to be within 0-255 range
         shift &= 255;
@@ -161,12 +161,12 @@ export class SafeMath {
         }
 
         // Determine how many full 64-bit segments we are shifting
-        let segmentShift = (shift / bitsPerSegment) | 0;
-        let bitShift = shift % bitsPerSegment;
+        const segmentShift = (shift / bitsPerSegment) | 0;
+        const bitShift = shift % bitsPerSegment;
 
-        let segments = [value.lo1, value.lo2, value.hi1, value.hi2];
+        const segments = [value.lo1, value.lo2, value.hi1, value.hi2];
 
-        let result = new Array<u64>(4).fill(0);
+        const result = new Array<u64>(4).fill(0);
 
         for (let i = 0; i < segments.length; i++) {
             if (i + segmentShift < segments.length) {

package/runtime/types/index.ts

@@ -2,7 +2,7 @@ import { Map } from '../generic/Map';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { MemorySlotData } from '../memory/MemorySlot';
 import { u256 } from 'as-bignum/assembly';
-import { Address } from './Address';
+import { BytesReader } from '../buffer/BytesReader';
 
 export type PointerStorage = Map<MemorySlotPointer, MemorySlotData<u256>>;
-export type BlockchainStorage = Map<Address, PointerStorage>;
+export type Calldata = NonNullable<BytesReader>;

package/runtime/utils/box.ts

@@ -0,0 +1,115 @@
+import { encodeHex, encodeHexUTF8 } from "./hex";
+
+export function nullptr<T>(): T {
+  return changetype<T>(0);
+}
+
+export class Box {
+  public start: usize;
+  public len: usize;
+  constructor(start: usize, len: usize) {
+    this.start = start;
+    this.len = len;
+  }
+  toHexString(): string {
+    return encodeHex(this.start, this.len);
+  }
+  toHexUTF8(): ArrayBuffer {
+    return encodeHexUTF8(this.start, this.len);
+  }
+  static concat(data: Array<Box>): ArrayBuffer {
+    const result = new ArrayBuffer(
+      data.reduce<i32>((r: i32, v: Box, i: i32, ary: Array<Box>) => {
+        return r + <i32>v.len;
+      }, 0),
+    );
+    data.reduce<usize>((r: usize, v: Box, i: i32, ary: Array<Box>) => {
+      memory.copy(r, v.start, v.len);
+      return r + v.len;
+    }, changetype<usize>(result));
+    return result;
+  }
+
+  shift(): Box {
+    if (this.len == 0) {
+      return nullptr<Box>();
+    }
+    this.start = this.start + 1;
+    this.len = this.len - 1;
+    return this;
+  }
+
+  sliceFrom(start: usize): Box {
+    return new Box(this.start + start, this.len - start);
+  }
+
+  sliceTo(ptr: usize): Box {
+    if (ptr > this.start + this.len) {
+      throw new Error("ptr is out of bounds");
+    }
+    return new Box(this.start, ptr - this.start);
+  }
+  shrinkFront(distance: usize): Box {
+    this.start = this.start + distance;
+    this.len = this.len - distance;
+    return this;
+  }
+  growFront(distance: usize): Box {
+    this.start = this.start - distance;
+    this.len = this.len + distance;
+    return this;
+  }
+  shrinkBack(distance: usize): Box {
+    this.len = this.len - distance;
+    return this;
+  }
+  growBack(distance: usize): Box {
+    this.len = this.len + distance;
+    return this;
+  }
+  setLength(len: usize): Box {
+    this.len = len;
+    return this;
+  }
+  toArrayBuffer(): ArrayBuffer {
+    const result = new ArrayBuffer(<i32>this.len);
+    memory.copy(changetype<usize>(result), this.start, this.len);
+    return result;
+  }
+  isEmpty(): boolean {
+    return this.len == 0;
+  }
+  static from(data: ArrayBuffer): Box {
+    return new Box(changetype<usize>(data), data.byteLength);
+  }
+  static copy(data: ArrayBuffer): Box {
+    const ptr = heap.alloc(data.byteLength);
+    memory.copy(ptr, changetype<usize>(data), <usize>data.byteLength);
+    return new Box(ptr, <usize>data.byteLength);
+  }
+  static freeCopy(v: Box): void {
+    heap.free(v.start);
+  }
+  static fromTyped<T>(v: T): Box {
+    // const buffer = new ArrayBuffer(sizeof<T>(v));
+    const buffer = new ArrayBuffer(offsetof<T>());
+    store<T>(changetype<usize>(buffer), v);
+    return Box.copy(buffer);
+  }
+}
+export class RCBox extends Box {
+  public buffer: ArrayBuffer;
+  constructor(v: ArrayBuffer) {
+    super(changetype<usize>(v), <usize>v.byteLength);
+    this.buffer = v;
+  }
+  static from(v: ArrayBuffer): RCBox {
+    return new RCBox(v);
+  }
+  static fromTyped<T>(v: T): RCBox {
+    // const buffer = new ArrayBuffer(sizeof<T>(v));
+    const buffer = new ArrayBuffer(offsetof<T>());
+    store<T>(changetype<usize>(buffer), v);
+    return RCBox.from(buffer);
+  }
+}

package/runtime/utils/hex.ts

@@ -0,0 +1,60 @@
+const hexLookupTable: StaticArray<u8> = [
+  48, 48, 48, 49, 48, 50, 48, 51, 48, 52, 48, 53, 48, 54, 48, 55, 48, 56, 48,
+  57, 48, 97, 48, 98, 48, 99, 48, 100, 48, 101, 48, 102, 49, 48, 49, 49, 49, 50,
+  49, 51, 49, 52, 49, 53, 49, 54, 49, 55, 49, 56, 49, 57, 49, 97, 49, 98, 49,
+  99, 49, 100, 49, 101, 49, 102, 50, 48, 50, 49, 50, 50, 50, 51, 50, 52, 50, 53,
+  50, 54, 50, 55, 50, 56, 50, 57, 50, 97, 50, 98, 50, 99, 50, 100, 50, 101, 50,
+  102, 51, 48, 51, 49, 51, 50, 51, 51, 51, 52, 51, 53, 51, 54, 51, 55, 51, 56,
+  51, 57, 51, 97, 51, 98, 51, 99, 51, 100, 51, 101, 51, 102, 52, 48, 52, 49, 52,
+  50, 52, 51, 52, 52, 52, 53, 52, 54, 52, 55, 52, 56, 52, 57, 52, 97, 52, 98,
+  52, 99, 52, 100, 52, 101, 52, 102, 53, 48, 53, 49, 53, 50, 53, 51, 53, 52, 53,
+  53, 53, 54, 53, 55, 53, 56, 53, 57, 53, 97, 53, 98, 53, 99, 53, 100, 53, 101,
+  53, 102, 54, 48, 54, 49, 54, 50, 54, 51, 54, 52, 54, 53, 54, 54, 54, 55, 54,
+  56, 54, 57, 54, 97, 54, 98, 54, 99, 54, 100, 54, 101, 54, 102, 55, 48, 55, 49,
+  55, 50, 55, 51, 55, 52, 55, 53, 55, 54, 55, 55, 55, 56, 55, 57, 55, 97, 55,
+  98, 55, 99, 55, 100, 55, 101, 55, 102, 56, 48, 56, 49, 56, 50, 56, 51, 56, 52,
+  56, 53, 56, 54, 56, 55, 56, 56, 56, 57, 56, 97, 56, 98, 56, 99, 56, 100, 56,
+  101, 56, 102, 57, 48, 57, 49, 57, 50, 57, 51, 57, 52, 57, 53, 57, 54, 57, 55,
+  57, 56, 57, 57, 57, 97, 57, 98, 57, 99, 57, 100, 57, 101, 57, 102, 97, 48, 97,
+  49, 97, 50, 97, 51, 97, 52, 97, 53, 97, 54, 97, 55, 97, 56, 97, 57, 97, 97,
+  97, 98, 97, 99, 97, 100, 97, 101, 97, 102, 98, 48, 98, 49, 98, 50, 98, 51, 98,
+  52, 98, 53, 98, 54, 98, 55, 98, 56, 98, 57, 98, 97, 98, 98, 98, 99, 98, 100,
+  98, 101, 98, 102, 99, 48, 99, 49, 99, 50, 99, 51, 99, 52, 99, 53, 99, 54, 99,
+  55, 99, 56, 99, 57, 99, 97, 99, 98, 99, 99, 99, 100, 99, 101, 99, 102, 100,
+  48, 100, 49, 100, 50, 100, 51, 100, 52, 100, 53, 100, 54, 100, 55, 100, 56,
+  100, 57, 100, 97, 100, 98, 100, 99, 100, 100, 100, 101, 100, 102, 101, 48,
+  101, 49, 101, 50, 101, 51, 101, 52, 101, 53, 101, 54, 101, 55, 101, 56, 101,
+  57, 101, 97, 101, 98, 101, 99, 101, 100, 101, 101, 101, 102, 102, 48, 102, 49,
+  102, 50, 102, 51, 102, 52, 102, 53, 102, 54, 102, 55, 102, 56, 102, 57, 102,
+  97, 102, 98, 102, 99, 102, 100, 102, 101, 102, 102,
+];
+
+export function encodeHexUTF8(start: usize, len: usize): ArrayBuffer {
+  let result = new ArrayBuffer(2 + <i32>len * 2);
+  store<u16>(changetype<usize>(result), <u16>0x7830);
+  for (let i: usize = 0; i < len; i++) {
+    store<u16>(
+      2 + changetype<usize>(result) + i * 2,
+      load<u16>(changetype<usize>(hexLookupTable) + 2 * load<u8>(start + i)),
+    );
+  }
+  return result;
+}
+export function encodeHex(start: usize, len: usize): string {
+  return String.UTF8.decode(encodeHexUTF8(start, len));
+}
+
+export function encodeHexFromBuffer(data: ArrayBuffer): string {
+  return encodeHex(changetype<usize>(data), data.byteLength);
+}
+
+export function decodeHex(hex: string): ArrayBuffer {
+  const result = new ArrayBuffer(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    store<u8>(
+      changetype<usize>(result) + i / 2,
+      <u8>parseInt(hex.substring(i, i + 2), 16),
+    );
+  }
+  return result;
+}

package/runtime/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./hex";
+export * from "./box";

package/runtime/universal/ABIRegistry.ts

@@ -1,27 +0,0 @@
-import { encodeSelector, Selector } from '../math/abi';
-import { BytesReader } from '../buffer/BytesReader';
-import { BytesWriter } from '../buffer/BytesWriter';
-
-export type Calldata = NonNullable<BytesReader>;
-
-class ABIRegistryBase {
-    private methodMap: Selector[] = [];
-
-    public getMethodSelectors(): Uint8Array {
-        const writer: BytesWriter = new BytesWriter(2 + this.methodMap.length * 4);
-        writer.writeMethodSelectorsMap(this.methodMap);
-
-        return writer.getBuffer();
-    }
-
-    // Register methods with their selectors and handlers
-    public defineMethodSelector(name: string): void {
-        const selector: u32 = encodeSelector(name);
-
-        if (!this.methodMap.includes(selector)) {
-            this.methodMap.push(selector);
-        }
-    }
-}
-
-export const ABIRegistry = new ABIRegistryBase();