@btc-vision/btc-runtime 1.0.0

package/LICENSE.md

@@ -0,0 +1,62 @@
+# Custom Software License Agreement
+
+## 1. Definitions
+
+- **"Licensor"** refers to the owner(s) and creator(s) of the software. The owner of the github organization "
+  btc-vision", "BlobMaster41".
+- **"User"** refers to any person or entity that accesses or uses the software.
+- **"Software"** refers to the source code, binaries, and documentation, whether in electronic or printed format, made
+  available by Licensor.
+
+## 2. Grant of License
+
+This License permits User to view the Software via the repository hosting the Software ("Hosting Service"). Except as
+provided in this Section, no other use of the Software is permitted. The User may not modify, copy, reproduce,
+republish, upload, post, transmit, or distribute the Software in any way.
+
+## 3. Restrictions
+
+- **Modification and Distribution**: User is prohibited from modifying, merging, distributing, sublicensing, and/or
+  selling copies of the Software.
+- **Commercial Use**: User is prohibited from using the Software for any commercial purposes.
+- **Reverse Engineering**: User is prohibited from reverse engineering, decompiling, or disassembling the Software.
+
+## 4. Termination
+
+This License is effective until terminated by the Licensor. It will terminate immediately without notice from the
+Licensor if User fails to comply with any provision of this License. Upon termination, User must destroy all copies of
+the Software.
+
+## 5. Copyright Notice
+
+The Software is © 2024 by the Licensor. All rights reserved.
+
+## 6. Governing Law
+
+This License shall be governed by and construed in accordance with the laws of [Toronto, Canada]. Any legal action or
+proceeding arising under this License will be brought exclusively in the courts located in [Toronto], and the parties
+hereby consent to personal jurisdiction and venue therein.
+
+## 7. Limitation of Liability
+
+In no event will the Licensor be liable for any damages, including, without limitation, indirect, incidental, special,
+consequential, or punitive damages arising out of the use of or inability to use the Software.
+
+## 8. Indemnification
+
+User agrees to indemnify, defend, and hold harmless the Licensor and its affiliates, officers, agents, employees, and
+partners from any claim or demand, including reasonable attorneys' fees, made by any third party due to or arising out
+of User's use of the Software, User's violation of this License, or User's violation of any rights of another.
+
+## 9. Breach of License
+
+Any breach of this License will result in immediate termination of User's rights under this License. Additionally, the
+Licensor reserves the right to pursue any legal action against the User in the event of a breach of this License.
+
+## 10. Acknowledgment
+
+User acknowledges that they have read this License, understand it, and agree to be bound by its terms and conditions.
+User also agrees that this License is the complete and exclusive statement of the agreement between the Licensor and the
+User and supersedes all proposals or prior agreements, oral or written, and any other communications between the
+Licensor and the User relating to the subject matter of this License.
+

package/README.md

@@ -0,0 +1,34 @@
+# OPNet Smart Contract Runtime
+
+![Bitcoin](https://img.shields.io/badge/Bitcoin-000?style=for-the-badge&logo=bitcoin&logoColor=white)
+![AssemblyScript](https://img.shields.io/badge/assembly%20script-%23000000.svg?style=for-the-badge&logo=assemblyscript&logoColor=white)
+![TypeScript](https://img.shields.io/badge/TypeScript-007ACC?style=for-the-badge&logo=typescript&logoColor=white)
+![NodeJS](https://img.shields.io/badge/Node%20js-339933?style=for-the-badge&logo=nodedotjs&logoColor=white)
+![WebAssembly](https://img.shields.io/badge/WebAssembly-654FF0?style=for-the-badge&logo=webassembly&logoColor=white)
+![NPM](https://img.shields.io/badge/npm-CB3837?style=for-the-badge&logo=npm&logoColor=white)
+
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+
+## Introduction
+
+The OPNet Smart Contract Runtime is a WebAssembly runtime that is designed to help developers write smart contracts for the OPNet blockchain.
+The runtime is written in AssemblyScript, a subset of TypeScript that compiles to WebAssembly.
+
+### Installation
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/btc-vision/btc-runtime.git
+   ```
+2. Navigate to the repository directory:
+   ```bash
+   cd btc-runtime
+   ```
+3. Install the necessary dependencies:
+   ```bash
+   npm i
+   ```
+
+## License
+
+View the license by clicking [here](https://github.com/btc-vision/wbtc/blob/main/LICENSE.md).

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "@btc-vision/btc-runtime",
+    "version": "1.0.0",
+    "description": "Bitcoin Smart Contract Runtime",
+    "main": "btc/index.ts",
+    "types": "btc/index.ts",
+    "scripts": {
+        "test": "jest",
+        "build": "asc runtime/index.ts --target release --measure -Ospeed --noAssert --optimizeLevel 3 --shrinkLevel 2 --converge --disable mutable-globals,sign-extension,nontrapping-f2i,bulk-memory --runtime stub --memoryBase 0 --lowMemoryLimit --uncheckedBehavior never --initialMemory 16 --maximumMemory 16 --exportRuntime"
+    },
+    "keywords": [
+        "bitcoin",
+        "smart",
+        "contract",
+        "runtime",
+        "opnet",
+        "OP_NET"
+    ],
+    "homepage": "https://opnet.org",
+    "author": "BlobMaster41",
+    "license": "LICENSE.MD",
+    "devDependencies": {
+        "@types/node": "^20.11.30",
+        "assemblyscript": "^0.27.25",
+        "prettier": "^3.2.5"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/BlobMaster41/btc-runtime.git"
+    },
+    "type": "module",
+    "files": [
+        "package.json",
+        "runtime",
+        "runtime/*.ts",
+        "runtime/**/*.ts",
+        "!**/*.js.map",
+        "!**/*.tsbuildinfo"
+    ],
+    "dependencies": {
+        "@assemblyscript/loader": "^0.27.25",
+        "as-bignum": "^0.3.0",
+        "gulplog": "^2.2.0",
+        "ts-node": "^10.9.2"
+    }
+}

package/runtime/buffer/BytesReader.ts

@@ -0,0 +1,193 @@
+import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
+import { Selector } from '../math/abi';
+import { u256 } from 'as-bignum/assembly';
+import { Revert } from '../types/Revert';
+import { Map } from '../generic/Map';
+
+@final
+export class BytesReader {
+    private readonly buffer: DataView;
+
+    private currentOffset: i32 = 0;
+
+    constructor(bytes: Uint8Array) {
+        this.buffer = new DataView(bytes.buffer);
+    }
+
+    public readU8(): u8 {
+        this.verifyEnd(this.currentOffset + 1);
+
+        return this.buffer.getUint8(this.currentOffset++);
+    }
+
+    public readU16(): u16 {
+        this.verifyEnd(this.currentOffset + 2);
+
+        const value = this.buffer.getUint16(this.currentOffset, true);
+        this.currentOffset += 2;
+
+        return value;
+    }
+
+    public readU32(le: boolean = true): u32 {
+        this.verifyEnd(this.currentOffset + 4);
+
+        const value = this.buffer.getUint32(this.currentOffset, le);
+        this.currentOffset += 4;
+        return value;
+    }
+
+    public readU64(): u64 {
+        this.verifyEnd(this.currentOffset + 8);
+
+        const value = this.buffer.getUint64(this.currentOffset, true);
+        this.currentOffset += 8;
+
+        return value;
+    }
+
+    public readU256(): u256 {
+        const next32Bytes: u8[] = [];
+        for (let i = 0; i < 32; i++) {
+            next32Bytes[i] = this.readU8();
+        }
+
+        return u256.fromBytesBE(next32Bytes);
+    }
+
+    public readBytes(length: u32, zeroStop: boolean = false): Uint8Array {
+        this.verifyEnd(this.currentOffset + length);
+
+        let bytes: Uint8Array = new Uint8Array(length);
+        for (let i: u32 = 0; i < length; i++) {
+            const byte: u8 = this.readU8();
+            if (zeroStop && byte === 0) {
+                bytes = bytes.slice(0, i);
+
+                this.currentOffset += length - (i + 1);
+                break;
+            }
+
+            bytes[i] = byte;
+        }
+
+        return bytes;
+    }
+
+    public readMultiBytesAddressMap(): Map<Address, Uint8Array[]> {
+        const map: Map<Address, Uint8Array[]> = new Map<Address, Uint8Array[]>();
+        const size: u8 = this.readU8();
+
+        if (size > 8) throw new Revert('Too many contract called.');
+
+        for (let i: u8 = 0; i < size; i++) {
+            const address: Address = this.readAddress();
+            const responseSize: u8 = this.readU8();
+
+            if (responseSize > 10) throw new Revert('Too many calls.');
+
+            const calls: Uint8Array[] = [];
+            for (let j: u8 = 0; j < responseSize; j++) {
+                const response: Uint8Array = this.readBytesWithLength();
+                calls.push(response);
+            }
+
+            map.set(address, calls);
+        }
+
+        return map;
+    }
+
+    public readBytesWithLength(): Uint8Array {
+        const length = this.readU32();
+
+        return this.readBytes(length);
+    }
+
+    public readString(length: u16): string {
+        const bytes = this.readBytes(length, true);
+
+        return String.UTF8.decode(bytes.buffer);
+    }
+
+    public readTuple(): u256[] {
+        const length = this.readU32();
+        const result: u256[] = new Array<u256>(length);
+
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU256();
+        }
+
+        return result;
+    }
+
+    public readAddressValueTuple(): Map<Address, u256> {
+        const length: u16 = this.readU16();
+        const result = new Map<Address, u256>();
+
+        for (let i: u16 = 0; i < length; i++) {
+            const address = this.readAddress();
+            const value = this.readU256();
+
+            if (result.has(address)) throw new Revert('Duplicate address found in map');
+
+            result.set(address, value);
+        }
+
+        return result;
+    }
+
+    public readSelector(): Selector {
+        return this.readU32(false);
+    }
+
+    public readStringWithLength(): string {
+        const length = this.readU16();
+
+        return this.readString(length);
+    }
+
+    public readBoolean(): boolean {
+        return this.readU8() !== 0;
+    }
+
+    public readFloat(): f32 {
+        const value = this.buffer.getFloat32(this.currentOffset, true);
+        this.currentOffset += 4;
+
+        return value;
+    }
+
+    public readAddress(): Address {
+        return this.readString(ADDRESS_BYTE_LENGTH);
+    }
+
+    public getOffset(): i32 {
+        return this.currentOffset;
+    }
+
+    public setOffset(offset: i32): void {
+        this.currentOffset = offset;
+    }
+
+    public verifyEnd(size: i32): void {
+        if (this.currentOffset > this.buffer.byteLength) {
+            throw new Error(`Expected to read ${size} bytes but read ${this.currentOffset} bytes`);
+        }
+    }
+
+    private verifyChecksum(): void {
+        const writtenChecksum = this.readU32();
+
+        let checksum: u32 = 0;
+        for (let i = 0; i < this.buffer.byteLength; i++) {
+            checksum += this.buffer.getUint8(i);
+        }
+
+        checksum = checksum % 2 ** 32;
+
+        if (checksum !== writtenChecksum) {
+            throw new Error('Invalid checksum for buffer');
+        }
+    }
+}

package/runtime/buffer/BytesWriter.ts

@@ -0,0 +1,322 @@
+import { u256 } from 'as-bignum/assembly';
+import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
+import { Selector } from '../math/abi';
+import { BytesReader } from './BytesReader';
+import { SelectorsMap } from '../universal/ABIRegistry';
+import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { MemorySlotData } from '../memory/MemorySlot';
+import { cyrb53a } from '../math/cyrb53';
+import { Revert } from '../types/Revert';
+import { Map } from '../generic/Map';
+import { BlockchainStorage, PointerStorage } from '../types';
+
+export enum BufferDataType {
+    U8 = 0,
+    U16 = 1,
+    U32 = 2,
+    U64 = 3,
+    U256 = 4,
+    ADDRESS = 5,
+    STRING = 6,
+    BOOLEAN = 7,
+}
+
+@final
+export class BytesWriter {
+    private currentOffset: u32 = 0;
+    private buffer: DataView;
+
+    private selectorDatatype: u8[] = [];
+
+    constructor(
+        length: i32 = 1,
+        private readonly trackDataTypes: boolean = false,
+    ) {
+        this.buffer = new DataView(new ArrayBuffer(length));
+    }
+
+    public bufferLength(): u32 {
+        return this.buffer.byteLength;
+    }
+
+    public writeU8(value: u8): void {
+        if (this.trackDataTypes) this.selectorDatatype.push(u8(BufferDataType.U8));
+
+        this.allocSafe(1);
+        this.buffer.setUint8(this.currentOffset++, value);
+    }
+
+    public writeU16(value: u16): void {
+        if (this.trackDataTypes) this.selectorDatatype.push(u8(BufferDataType.U16));
+
+        this.allocSafe(2);
+        this.buffer.setUint16(this.currentOffset, value, true);
+        this.currentOffset += 2;
+    }
+
+    public writeU32(value: u32, le: boolean = true): void {
+        if (this.trackDataTypes) this.selectorDatatype.push(u8(BufferDataType.U32));
+
+        this.allocSafe(4);
+        this.buffer.setUint32(this.currentOffset, value, le);
+        this.currentOffset += 4;
+    }
+
+    public writeU64(value: u64): void {
+        if (this.trackDataTypes) this.selectorDatatype.push(u8(BufferDataType.U64));
+
+        this.allocSafe(8);
+        this.buffer.setUint64(this.currentOffset, value || 0, true);
+        this.currentOffset += 8;
+    }
+
+    public writeStorage(storage: BlockchainStorage): void {
+        this.writeU32(storage.size);
+
+        const keys: Address[] = storage.keys();
+        const values: PointerStorage[] = storage.values();
+
+        for (let i: i32 = 0; i < keys.length; i++) {
+            const address: Address = keys[i];
+            const storage: PointerStorage = values[i];
+
+            this.writeAddress(address);
+
+            const subKeys: MemorySlotPointer[] = storage.keys();
+            const subValues: MemorySlotData<u256>[] = storage.values();
+
+            this.writeU32(subKeys.length);
+
+            for (let j: i32 = 0; j < subKeys.length; j++) {
+                const pointer: MemorySlotPointer = subKeys[j];
+                const value: MemorySlotData<u256> = subValues[j];
+
+                this.writeU256(pointer);
+                this.writeU256(value);
+            }
+        }
+    }
+
+    public writeSelector(value: Selector): void {
+        this.writeU32(value, false);
+    }
+
+    public writeBoolean(value: boolean): void {
+        if (this.trackDataTypes) this.selectorDatatype.push(u8(BufferDataType.BOOLEAN));
+
+        this.writeU8(value ? 1 : 0);
+    }
+
+    public writeU256(value: u256): void {
+        if (this.trackDataTypes) this.selectorDatatype.push(u8(BufferDataType.U256));
+        this.allocSafe(32);
+
+        const bytes = value.toUint8Array(true);
+        for (let i: i32 = 0; i < 32; i++) {
+            this.writeU8(bytes[i] || 0);
+        }
+    }
+
+    public writeTuple(value: u256[]): void {
+        this.allocSafe(4 + value.length * 32);
+        this.writeU32(u32(value.length));
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeU256(value[i]);
+        }
+    }
+
+    public writeBytes(value: Uint8Array): void {
+        this.allocSafe(value.length);
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeU8(value[i]);
+        }
+    }
+
+    public writeBytesWithLength(value: Uint8Array): void {
+        const length: u32 = u32(value.byteLength);
+        this.allocSafe(length + 4);
+        this.writeU32(length);
+
+        for (let i: u32 = 0; i < length; i++) {
+            this.writeU8(value[i]);
+        }
+    }
+
+    public writeString(value: string): void {
+        if (this.trackDataTypes) this.selectorDatatype.push(u8(BufferDataType.STRING));
+
+        for (let i: i32 = 0; i < value.length; i++) {
+            this.writeU8(u8(value.charCodeAt(i)));
+        }
+    }
+
+    public writeAddress(value: Address): void {
+        if (this.trackDataTypes) this.selectorDatatype.push(u8(BufferDataType.ADDRESS));
+
+        const bytes = this.fromAddress(value);
+        this.writeBytes(bytes);
+    }
+
+    public writeStringWithLength(value: string): void {
+        this.writeU16(u16(value.length));
+
+        this.writeString(value);
+    }
+
+    public writeViewSelectorMap(map: SelectorsMap): void {
+        this.writeU16(u16(map.size));
+
+        const keys = map.keys();
+        for (let i = 0; i < keys.length; i++) {
+            const key: u32 = keys[i] as u32;
+            const value = map.get(key);
+
+            this.writeBytes(value);
+        }
+    }
+
+    public writeAddressValueTupleMap(map: Map<Address, u256>): void {
+        if (map.size > 65535) throw new Revert('Map size is too large');
+        this.writeU16(u16(map.size));
+
+        const keys = map.keys();
+        for (let i = 0; i < keys.length; i++) {
+            const key: Address = keys[i];
+            const value: u256 = map.get(key) || u256.Zero;
+
+            this.writeAddress(key);
+            this.writeU256(value);
+        }
+    }
+
+    public writeLimitedAddressBytesMap(map: Map<Address, Uint8Array[]>): void {
+        if (map.size > 8) throw new Revert('Too many contract called.'); // no more than 8 different contracts.
+
+        this.writeU8(u8(map.size));
+
+        const keys: Address[] = map.keys();
+        for (let i: i32 = 0; i < keys.length; i++) {
+            const address: Address = keys[i];
+            const calls: Uint8Array[] = map.get(address) || [];
+
+            if (calls.length > 10) throw new Revert('Too many calls.'); // no more than 16 different calls.
+
+            this.writeAddress(address);
+            this.writeU8(u8(calls.length));
+
+            for (let j: i32 = 0; j < calls.length; j++) {
+                this.writeBytesWithLength(calls[j]);
+            }
+        }
+    }
+
+    public writeMethodSelectorsMap(map: Selector[]): void {
+        this.writeU16(u16(map.length));
+
+        for (let i = 0; i < map.length; i++) {
+            this.writeSelector(map[i]);
+        }
+    }
+
+    public getBuffer(clear: boolean = true): Uint8Array {
+        const buf = new Uint8Array(this.buffer.byteLength);
+        for (let i: u32 = 0; i < u32(this.buffer.byteLength); i++) {
+            buf[i] = this.buffer.getUint8(i);
+        }
+
+        if (clear) this.clear();
+
+        return buf;
+    }
+
+    public toBytesReader(): BytesReader {
+        return new BytesReader(this.getBuffer());
+    }
+
+    public getOffset(): u32 {
+        return this.currentOffset;
+    }
+
+    public setOffset(offset: u32): void {
+        this.currentOffset = offset;
+    }
+
+    public clear(): void {
+        this.currentOffset = 0;
+        this.buffer = this.getDefaultBuffer();
+        this.selectorDatatype = [];
+    }
+
+    public allocSafe(size: u32): void {
+        if (this.currentOffset + size > u32(this.buffer.byteLength)) {
+            const sizeDiff: u32 = size - (u32(this.buffer.byteLength) - this.currentOffset);
+
+            this.resize(sizeDiff);
+        }
+    }
+
+    public writeABISelector(name: string, selector: Selector): void {
+        this.writeStringWithLength(name);
+        this.writeSelector(selector);
+    }
+
+    public getSelectorDataType(): u64 {
+        let hash: u64 = 0;
+        if (this.selectorDatatype.length === 0) return hash;
+
+        return cyrb53a(this.selectorDatatype);
+    }
+
+    private getChecksum(): u32 {
+        let checksum: u32 = 0;
+        for (let i = 0; i < this.buffer.byteLength; i++) {
+            checksum += this.buffer.getUint8(i);
+        }
+
+        return checksum % 2 ** 32;
+    }
+
+    private writeMethodSelectorMap(value: Set<Selector>): void {
+        this.writeU16(u16(value.size));
+
+        const keys = value.values();
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+
+            this.writeSelector(key);
+        }
+    }
+
+    private fromAddress(value: Address): Uint8Array {
+        if (value.length > i32(ADDRESS_BYTE_LENGTH)) {
+            throw new Revert('Address is too long');
+        }
+
+        const bytes: Uint8Array = new Uint8Array(ADDRESS_BYTE_LENGTH);
+        for (let i: i32 = 0; i < value.length; i++) {
+            bytes[i] = value.charCodeAt(i);
+        }
+
+        for (let i: u8 = u8(value.length); i < ADDRESS_BYTE_LENGTH; i++) {
+            bytes[i] = 0;
+        }
+
+        return bytes;
+    }
+
+    private resize(size: u32): void {
+        const buf: Uint8Array = new Uint8Array(u32(this.buffer.byteLength) + size);
+
+        for (let i: i32 = 0; i < this.buffer.byteLength; i++) {
+            buf[i] = this.buffer.getUint8(i);
+        }
+
+        this.buffer = new DataView(buf.buffer);
+    }
+
+    private getDefaultBuffer(length: i32 = 1): DataView {
+        return new DataView(new ArrayBuffer(length));
+    }
+}