@btc-vision/btc-runtime 1.0.0

package/runtime/env/BTCEnvironment.ts

@@ -0,0 +1,372 @@
+import { Address, PotentialAddress } 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 { Potential } from '../lang/Definitions';
+import { Map } from '../generic/Map';
+import { OP_NET } from '../contracts/OP_NET';
+import { BlockchainStorage, PointerStorage } from '../types';
+
+export * from '../env/global';
+
+@final
+export class BlockchainEnvironment {
+    private static readonly runtimeException: string = 'RuntimeException';
+
+    private storage: BlockchainStorage = new Map();
+    private initializedStorage: BlockchainStorage = new Map();
+
+    private externalCalls: Map<Address, Uint8Array[]> = new Map();
+    private externalCallsResponse: Map<Address, Uint8Array[]> = new Map();
+
+    private events: NetEvent[] = [];
+
+    private _callee: PotentialAddress = null;
+    private _caller: PotentialAddress = null;
+    private currentBlock: u256 = u256.Zero;
+
+    constructor() {}
+
+    private _contract: Potential<OP_NET> = null;
+
+    public get contract(): OP_NET {
+        if (!this._contract) {
+            throw this.error('Contract is required');
+        }
+
+        return this._contract as OP_NET;
+    }
+
+    public set contract(contract: OP_NET) {
+        this._contract = contract;
+    }
+
+    private _nextPointer: u8 = 0;
+
+    public get nextPointer(): u8 {
+        this._nextPointer += 1;
+
+        return this._nextPointer;
+    }
+
+    public _owner: Potential<Address> = null;
+
+    public get owner(): Address {
+        if (!this._owner) {
+            throw this.error('Owner is required');
+        }
+
+        return this._owner as Address;
+    }
+
+    public _contractAddress: Potential<Address> = null;
+
+    public get contractAddress(): Address {
+        if (!this._contractAddress) {
+            throw this.error('Contract address is required');
+        }
+
+        return this._contractAddress as Address;
+    }
+
+    public get blockNumber(): u256 {
+        return this.currentBlock;
+    }
+
+    public callee(): Address {
+        if (!this._callee) {
+            throw this.error('Callee is required');
+        }
+
+        return this._callee as Address;
+    }
+
+    public caller(): Address {
+        if (!this._caller) {
+            throw this.error('Caller is required');
+        }
+
+        return this._caller as Address;
+    }
+
+    public setEnvironment(data: Uint8Array): void {
+        const reader: BytesReader = new BytesReader(data);
+
+        this._caller = reader.readAddress();
+        this._callee = reader.readAddress();
+        this.currentBlock = reader.readU256();
+
+        this._owner = reader.readAddress();
+        this._contractAddress = reader.readAddress();
+    }
+
+    public call(destinationContract: Address, calldata: BytesWriter): BytesReader {
+        if (destinationContract === this._callee) {
+            throw this.error('Cannot call self');
+        }
+
+        if (!this.externalCalls.has(destinationContract)) {
+            this.externalCalls.set(destinationContract, []);
+        }
+
+        const externalCalls = this.externalCalls.get(destinationContract);
+        const buffer = calldata.getBuffer();
+        externalCalls.push(buffer);
+
+        const response: Potential<Uint8Array> = this.getExternalCallResponse(
+            destinationContract,
+            externalCalls.length - 1,
+        );
+        if (!response) {
+            throw this.error('external call failed');
+        }
+
+        return new BytesReader(response);
+    }
+
+    public getCalls(): Uint8Array {
+        const buffer: BytesWriter = new BytesWriter();
+
+        buffer.writeLimitedAddressBytesMap(this.externalCalls);
+        this.externalCalls.clear();
+
+        return buffer.getBuffer();
+    }
+
+    public loadCallsResponse(responses: Uint8Array): void {
+        const memoryReader: BytesReader = new BytesReader(responses);
+
+        this.externalCallsResponse = memoryReader.readMultiBytesAddressMap();
+    }
+
+    public addEvent(event: NetEvent): void {
+        if (this.events.length >= i32(MAX_EVENTS)) {
+            throw this.error(`Too many events in the same transaction.`);
+        }
+
+        this.events.push(event);
+    }
+
+    public getEvents(): Uint8Array {
+        const eventLength: u8 = u8(this.events.length);
+        if (eventLength > MAX_EVENTS) {
+            throw this.error('Too many events');
+        }
+
+        const buffer: BytesWriter = new BytesWriter();
+        buffer.writeU8(eventLength);
+
+        for (let i: u8 = 0; i < eventLength; i++) {
+            const event: NetEvent = this.events[i];
+
+            buffer.writeStringWithLength(event.eventType);
+            buffer.writeU64(event.getEventDataSelector());
+            buffer.writeBytesWithLength(event.getEventData());
+        }
+
+        return buffer.getBuffer();
+    }
+
+    public getStorageAt(
+        address: Address,
+        pointer: u16,
+        subPointer: MemorySlotPointer,
+        defaultValue: MemorySlotData<u256>,
+    ): MemorySlotData<u256> {
+        this.ensureStorageAtAddress(address);
+
+        const pointerHash: MemorySlotPointer = encodePointerHash(pointer, subPointer);
+        this.ensureStorageAtPointer(address, pointerHash, defaultValue);
+
+        const storage: PointerStorage = this.storage.get(address);
+
+        // maybe find a better way for this
+        const allKeys: u256[] = storage.keys();
+        for (let i: i32 = 0; i < allKeys.length; i++) {
+            const v: u256 = allKeys[i];
+
+            if (u256.eq(v, pointerHash)) {
+                return storage.get(v);
+            }
+        }
+
+        return defaultValue;
+    }
+
+    public hasStorageAt(address: Address, pointer: u16, subPointer: MemorySlotPointer): bool {
+        this.ensureStorageAtAddress(address);
+
+        // We mark zero as the default value for the storage, if something is 0, the storage slot get deleted or is non-existent
+        const val: u256 = this.getStorageAt(address, pointer, subPointer, u256.Zero);
+        return val != u256.Zero;
+    }
+
+    public setStorageAt(
+        address: Address,
+        pointer: u16,
+        keyPointer: MemorySlotPointer,
+        value: MemorySlotData<u256>,
+        defaultValue: MemorySlotData<u256>,
+    ): void {
+        this.ensureStorageAtAddress(address);
+
+        const pointerHash: u256 = encodePointerHash(pointer, keyPointer);
+        this.ensureStorageAtPointer(address, pointerHash, defaultValue);
+
+        this._internalSetStorageAt(address, pointerHash, value);
+    }
+
+    public getViewSelectors(): Uint8Array {
+        return ABIRegistry.getViewSelectors();
+    }
+
+    public getMethodSelectors(): Uint8Array {
+        return ABIRegistry.getMethodSelectors();
+    }
+
+    public getWriteMethods(): Uint8Array {
+        return ABIRegistry.getWriteMethods();
+    }
+
+    public loadStorage(data: Uint8Array): void {
+        this.purgeMemory();
+
+        const memoryReader: BytesReader = new BytesReader(data);
+        const contractsSize: u32 = memoryReader.readU32();
+
+        for (let i: u32 = 0; i < contractsSize; i++) {
+            const address: Address = memoryReader.readAddress();
+            const storageSize: u32 = memoryReader.readU32();
+
+            this.ensureStorageAtAddress(address);
+            const storage: PointerStorage = this.storage.get(address);
+
+            for (let j: u32 = 0; j < storageSize; j++) {
+                const keyPointer: MemorySlotPointer = memoryReader.readU256();
+                const value: MemorySlotData<u256> = memoryReader.readU256();
+
+                storage.set(keyPointer, value);
+            }
+        }
+    }
+
+    public storageToBytes(): Uint8Array {
+        const memoryWriter: BytesWriter = new BytesWriter();
+        memoryWriter.writeStorage(this.storage);
+
+        //this.storage.clear();
+
+        return memoryWriter.getBuffer();
+    }
+
+    public initializedStorageToBytes(): Uint8Array {
+        const memoryWriter: BytesWriter = new BytesWriter();
+        memoryWriter.writeStorage(this.initializedStorage);
+
+        //this.initializedStorage.clear();
+
+        return memoryWriter.getBuffer();
+    }
+
+    private purgeMemory(): void {
+        this.storage.clear();
+        this.initializedStorage.clear();
+
+        this.events = [];
+
+        this.externalCallsResponse.clear();
+        this.externalCalls.clear();
+    }
+
+    private requireInitialStorage(address: Address, pointerHash: u256, defaultValue: u256): void {
+        if (!this.initializedStorage.has(address)) {
+            this.initializedStorage.set(address, new Map<u256, MemorySlotData<u256>>());
+        }
+
+        //load(pointerHash);
+
+        const storage = this.initializedStorage.get(address);
+        storage.set(pointerHash, defaultValue);
+    }
+
+    private getExternalCallResponse(
+        destinationContract: Address,
+        index: i32,
+    ): Potential<Uint8Array> {
+        if (!this.externalCallsResponse.has(destinationContract)) {
+            this.externalCallsResponse.set(destinationContract, []);
+        }
+
+        const externalCallsResponse = this.externalCallsResponse.get(destinationContract);
+        return externalCallsResponse[index] || null;
+    }
+
+    private error(msg: string): Error {
+        return new Error(`${BlockchainEnvironment.runtimeException}: ${msg}`);
+    }
+
+    private _internalSetStorageAt(
+        address: Address,
+        pointerHash: u256,
+        value: MemorySlotData<u256>,
+    ): void {
+        const storage: PointerStorage = this.storage.get(address);
+        const keys: u256[] = storage.keys();
+
+        // Delete the old value, there is a bug with u256 and maps.
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+
+            if (u256.eq(key, pointerHash)) {
+                storage.delete(key);
+            }
+        }
+
+        //store(pointerHash, value);
+
+        storage.set(pointerHash, value);
+    }
+
+    private ensureStorageAtAddress(address: Address): void {
+        if (!this.storage.has(address)) {
+            this.storage.set(address, new Map<u256, MemorySlotData<u256>>());
+        }
+    }
+
+    private hasPointerStorageHash(storage: PointerStorage, pointer: MemorySlotPointer): bool {
+        const keys = storage.keys();
+
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+
+            if (u256.eq(key, pointer)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private ensureStorageAtPointer(
+        address: Address,
+        pointerHash: MemorySlotPointer,
+        defaultValue: MemorySlotData<u256>,
+    ): void {
+        if (!this.storage.has(address)) {
+            throw this.error(`Storage slot not found for address ${address}`);
+        }
+
+        // !!! -- IMPORTANT -- !!!. We have to tell the indexer that we need this storage slot to continue even if it's already defined.
+        this.requireInitialStorage(address, pointerHash, defaultValue);
+
+        const storage: PointerStorage = this.storage.get(address);
+        if (!this.hasPointerStorageHash(storage, pointerHash)) {
+            this._internalSetStorageAt(address, pointerHash, defaultValue);
+        }
+    }
+}

package/runtime/env/global.ts

@@ -0,0 +1,18 @@
+import { u256 } from "as-bignum/assembly/integer/u256";
+import { Address } from "../types/Address";
+
+// @ts-ignore
+@external('env', 'load')
+export declare function load(pointer: u256): u256;
+
+// @ts-ignore
+@external('env', 'store')
+export declare function store(pointer: u256, value: u256): void;
+
+// @ts-ignore
+@external('env', 'deploy')
+export declare function deploy(bytecode: Uint8Array): Address;
+
+// @ts-ignore
+@external('env', 'call')
+export declare function call(callee: Address, calldata: Uint8Array): Uint8Array;

package/runtime/env/index.ts

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

package/runtime/events/NetEvent.ts

@@ -0,0 +1,27 @@
+import { BytesWriter } from '../buffer/BytesWriter';
+
+export const MAX_EVENT_DATA_SIZE: u32 = 256; // 256 bytes max per event.
+export const MAX_EVENTS: u8 = 8; // 8 events max per transactions.
+
+export abstract class NetEvent {
+    protected constructor(
+        public readonly eventType: string,
+        protected data: BytesWriter,
+    ) {}
+
+    public get length(): u32 {
+        return this.data.bufferLength();
+    }
+
+    public getEventDataSelector(): u64 {
+        return this.data.getSelectorDataType();
+    }
+
+    public getEventData(): Uint8Array {
+        if (this.data.bufferLength() > MAX_EVENT_DATA_SIZE) {
+            throw new Error('Event data length exceeds maximum length.');
+        }
+
+        return this.data.getBuffer();
+    }
+}

package/runtime/events/predefined/ApproveEvent.ts

@@ -0,0 +1,16 @@
+import { u256 } from 'as-bignum/assembly';
+import { Address } from '../../types/Address';
+import { NetEvent } from '../NetEvent';
+import { BytesWriter } from '../../buffer/BytesWriter';
+
+@final
+export class ApproveEvent extends NetEvent {
+    constructor(owner: Address, spender: Address, value: u256) {
+        const data: BytesWriter = new BytesWriter(1, true);
+        data.writeAddress(owner);
+        data.writeAddress(spender);
+        data.writeU256(value);
+
+        super('Approve', data);
+    }
+}

package/runtime/events/predefined/BurnEvent.ts

@@ -0,0 +1,13 @@
+import { u256 } from 'as-bignum/assembly';
+import { NetEvent } from '../NetEvent';
+import { BytesWriter } from '../../buffer/BytesWriter';
+
+@final
+export class BurnEvent extends NetEvent {
+    constructor(amount: u256) {
+        const data: BytesWriter = new BytesWriter(1, true);
+        data.writeU256(amount);
+
+        super('Burn', data);
+    }
+}

package/runtime/events/predefined/ClaimEvent.ts

@@ -0,0 +1,13 @@
+import { u256 } from 'as-bignum/assembly';
+import { NetEvent } from '../NetEvent';
+import { BytesWriter } from '../../buffer/BytesWriter';
+
+@final
+export class ClaimEvent extends NetEvent {
+    constructor(amount: u256) {
+        const data: BytesWriter = new BytesWriter(1, true);
+        data.writeU256(amount);
+
+        super('Claim', data);
+    }
+}

package/runtime/events/predefined/MintEvent.ts

@@ -0,0 +1,15 @@
+import { u256 } from 'as-bignum/assembly';
+import { NetEvent } from '../NetEvent';
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { Address } from '../../types/Address';
+
+@final
+export class MintEvent extends NetEvent {
+    constructor(address: Address, amount: u256) {
+        const data: BytesWriter = new BytesWriter(1, true);
+        data.writeAddress(address);
+        data.writeU256(amount);
+
+        super('Mint', data);
+    }
+}

package/runtime/events/predefined/StakeEvent.ts

@@ -0,0 +1,13 @@
+import { u256 } from 'as-bignum/assembly';
+import { NetEvent } from '../NetEvent';
+import { BytesWriter } from '../../buffer/BytesWriter';
+
+@final
+export class StakeEvent extends NetEvent {
+    constructor(amount: u256) {
+        const data: BytesWriter = new BytesWriter(1, true);
+        data.writeU256(amount);
+
+        super('Stake', data);
+    }
+}

package/runtime/events/predefined/TransferEvent.ts

@@ -0,0 +1,16 @@
+import { u256 } from 'as-bignum/assembly';
+import { NetEvent } from '../NetEvent';
+import { Address } from '../../types/Address';
+import { BytesWriter } from '../../buffer/BytesWriter';
+
+@final
+export class TransferEvent extends NetEvent {
+    constructor(from: Address, to: Address, amount: u256) {
+        const data: BytesWriter = new BytesWriter(1, true);
+        data.writeAddress(from);
+        data.writeAddress(to);
+        data.writeU256(amount);
+
+        super('Transfer', data);
+    }
+}

package/runtime/events/predefined/UnstakeEvent.ts

@@ -0,0 +1,13 @@
+import { u256 } from 'as-bignum/assembly';
+import { NetEvent } from '../NetEvent';
+import { BytesWriter } from '../../buffer/BytesWriter';
+
+@final
+export class UnstakeEvent extends NetEvent {
+    constructor(amount: u256) {
+        const data: BytesWriter = new BytesWriter(1, true);
+        data.writeU256(amount);
+
+        super('Unstake', data);
+    }
+}

package/runtime/events/predefined/index.ts

@@ -0,0 +1,7 @@
+export * from './ApproveEvent';
+export * from './BurnEvent';
+export * from './MintEvent';
+export * from './TransferEvent';
+export * from './ClaimEvent';
+export * from './StakeEvent';
+export * from './UnstakeEvent';

package/runtime/exports/index.ts

@@ -0,0 +1,57 @@
+import { Calldata } from '../universal/ABIRegistry';
+import { Blockchain } from '../env';
+import { Selector } from '../math/abi';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { BytesReader } from '../buffer/BytesReader';
+
+export function readMethod(method: Selector, data: Uint8Array): Uint8Array {
+    const calldata: Calldata = new BytesReader(data);
+    const result: BytesWriter = Blockchain.contract.callMethod(method, 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 getViewABI(): Uint8Array {
+    return Blockchain.getViewSelectors();
+}
+
+export function getMethodABI(): Uint8Array {
+    return Blockchain.getMethodSelectors();
+}
+
+export function getWriteMethods(): Uint8Array {
+    return Blockchain.getWriteMethods();
+}
+
+export function getModifiedStorage(): Uint8Array {
+    return Blockchain.storageToBytes();
+}
+
+export function initializeStorage(): Uint8Array {
+    return Blockchain.initializedStorageToBytes();
+}
+
+export function loadStorage(data: Uint8Array): void {
+    Blockchain.loadStorage(data);
+}
+
+export function loadCallsResponse(data: Uint8Array): void {
+    Blockchain.loadCallsResponse(data);
+}
+
+export function getCalls(): Uint8Array {
+    return Blockchain.getCalls();
+}
+
+export function setEnvironment(data: Uint8Array): void {
+    Blockchain.setEnvironment(data);
+}

package/runtime/generic/Map.ts

@@ -0,0 +1,55 @@
+import { Revert } from '../types/Revert';
+
+export class Map<K, V> {
+    private _keys: K[] = [];
+    private _values: V[] = [];
+
+    public get size(): i32 {
+        return this._keys.length;
+    }
+
+    public keys(): K[] {
+        return this._keys;
+    }
+
+    public values(): V[] {
+        return this._values;
+    }
+
+    public set(key: K, value: V): void {
+        const index: i32 = this._keys.indexOf(key);
+        if (index == -1) {
+            this._keys.push(key);
+            this._values.push(value);
+        } else {
+            this._values[index] = value;
+        }
+    }
+
+    public get(key: K): V {
+        const index: i32 = this._keys.indexOf(key);
+        if (index == -1) {
+            throw new Revert('Key not found in map');
+        }
+        return this._values[index];
+    }
+
+    public has(key: K): bool {
+        return this._keys.includes(key);
+    }
+
+    public delete(key: K): bool {
+        const index: i32 = this._keys.indexOf(key);
+        if (index == -1) {
+            return false;
+        }
+        this._keys.splice(index, 1);
+        this._values.splice(index, 1);
+        return true;
+    }
+
+    public clear(): void {
+        this._keys = [];
+        this._values = [];
+    }
+}