@btc-vision/btc-runtime 1.0.11 → 1.0.14

package/README.md

@@ -11,8 +11,8 @@
 
 ## 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.
+The OPNet Smart Contract Runtime contains all the necessary components to effectively create smart contracts on Bitcoin
+L1. The runtime is written in AssemblyScript.
 
 ### Installation
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.0.11",
+    "version": "1.0.14",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "types": "btc/index.ts",

package/runtime/buffer/BytesWriter.ts

@@ -299,7 +299,7 @@ export class BytesWriter {
 
     private fromAddress(value: Address): Uint8Array {
         if (value.length > i32(ADDRESS_BYTE_LENGTH)) {
-            throw new Revert('Address is too long');
+            throw new Revert(`Address is too long ${value.length} > ${ADDRESS_BYTE_LENGTH} bytes`);
         }
 
         const bytes: Uint8Array = new Uint8Array(ADDRESS_BYTE_LENGTH);

package/runtime/contracts/OP_20.ts

@@ -23,29 +23,28 @@ const transferSelector = encodeSelector('transfer');
 const transferFromSelector = encodeSelector('transferFrom');
 
 export abstract class OP_20 extends OP_NET implements IOP_20 {
-    public readonly decimals: u8 = 8;
-
-    public readonly name: string = `OP_20`;
-    public readonly symbol: string = `OP`;
-
     protected readonly allowanceMap: MultiAddressMemoryMap<Address, Address, MemorySlotData<u256>>;
     protected readonly balanceOfMap: AddressMemoryMap<Address, MemorySlotData<u256>>;
 
-    protected constructor(public readonly maxSupply: u256) {
+    protected constructor(
+        protected readonly maxSupply: u256,
+        protected readonly decimals: u8,
+        protected readonly name: string,
+        protected readonly symbol: string,
+    ) {
         super();
 
         this.allowanceMap = new MultiAddressMemoryMap<Address, Address, MemorySlotData<u256>>(
             Blockchain.nextPointer,
             u256.Zero,
         );
+
         this.balanceOfMap = new AddressMemoryMap<Address, MemorySlotData<u256>>(
             Blockchain.nextPointer,
             u256.Zero,
         );
 
-        const supplyPointer = Blockchain.nextPointer;
-        const supply: u256 = Blockchain.getStorageAt(supplyPointer, u256.Zero, u256.Zero);
-        this._totalSupply = new StoredU256(supplyPointer, u256.Zero, supply);
+        this._totalSupply = new StoredU256(Blockchain.nextPointer, u256.Zero, u256.Zero);
     }
 
     public _totalSupply: StoredU256;
@@ -156,10 +155,10 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
                 response.writeU8(this.decimals);
                 break;
             case encodeSelector('name'):
-                response.writeString(this.name);
+                response.writeStringWithLength(this.name);
                 break;
             case encodeSelector('symbol'):
-                response.writeString(this.symbol);
+                response.writeStringWithLength(this.symbol);
                 break;
             case encodeSelector('totalSupply'):
                 response.writeU256(this.totalSupply);
@@ -229,9 +228,7 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
         const caller = Blockchain.caller();
 
         if (onlyOwner) this.onlyOwner(callee);
-
         if (caller !== callee) throw new Revert(`callee != caller`);
-        if (callee !== this.owner) throw new Revert('Only indexers can mint tokens');
 
         if (!this.balanceOfMap.has(to)) {
             this.balanceOfMap.set(to, value);
@@ -271,14 +268,10 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
         const newBalance: u256 = SafeMath.sub(balance, value);
         this.balanceOfMap.set(caller, newBalance);
 
-        if (!this.balanceOfMap.has(to)) {
-            this.balanceOfMap.set(to, value);
-        } else {
-            const toBalance: u256 = this.balanceOfMap.get(to);
-            const newToBalance: u256 = SafeMath.add(toBalance, value);
+        const toBalance: u256 = this.balanceOfMap.get(to);
+        const newToBalance: u256 = SafeMath.add(toBalance, value);
 
-            this.balanceOfMap.set(to, newToBalance);
-        }
+        this.balanceOfMap.set(to, newToBalance);
 
         this.createTransferEvent(caller, to, value);
 
@@ -345,19 +338,19 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
         this.emitEvent(burnEvent);
     }
 
-    private createApproveEvent(owner: Address, spender: Address, value: u256): void {
+    protected createApproveEvent(owner: Address, spender: Address, value: u256): void {
         const approveEvent = new ApproveEvent(owner, spender, value);
 
         this.emitEvent(approveEvent);
     }
 
-    private createMintEvent(owner: Address, value: u256): void {
+    protected createMintEvent(owner: Address, value: u256): void {
         const mintEvent = new MintEvent(owner, value);
 
         this.emitEvent(mintEvent);
     }
 
-    private createTransferEvent(from: Address, to: Address, value: u256): void {
+    protected createTransferEvent(from: Address, to: Address, value: u256): void {
         const transferEvent = new TransferEvent(from, to, value);
 
         this.emitEvent(transferEvent);

package/runtime/contracts/interfaces/IOP_20.ts

@@ -3,10 +3,6 @@ import { Calldata } from '../../universal/ABIRegistry';
 import { StoredU256 } from '../../storage/StoredU256';
 
 export interface IOP_20 {
-    readonly name: string;
-    readonly symbol: string;
-
-    readonly decimals: u8;
     readonly _totalSupply: StoredU256;
 
     balanceOf(callData: Calldata): BytesWriter;

package/runtime/env/BTCEnvironment.ts

@@ -11,7 +11,7 @@ import { Potential } from '../lang/Definitions';
 import { Map } from '../generic/Map';
 import { OP_NET } from '../contracts/OP_NET';
 import { PointerStorage } from '../types';
-import { deploy, deployFromAddress, loadPointer, storePointer } from './global';
+import { callContract, deploy, deployFromAddress, loadPointer, log, storePointer } from './global';
 import { DeployContractResponse } from '../interfaces/DeployContractResponse';
 
 export * from '../env/global';
@@ -81,6 +81,10 @@ export class BlockchainEnvironment {
         return this.currentBlock;
     }
 
+    public get blockNumberU64(): u64 {
+        return this.currentBlock.toU64();
+    }
+
     public callee(): Address {
         if (!this._callee) {
             throw this.error('Callee is required');
@@ -111,25 +115,25 @@ export class BlockchainEnvironment {
     }
 
     public call(destinationContract: Address, calldata: BytesWriter): BytesReader {
-        /*if (destinationContract === this._callee) {
+        if (destinationContract === this._callee) {
             throw this.error('Cannot call self');
         }
 
-        const externalCalls = this.externalCalls.get(destinationContract);
-        const buffer = calldata.getBuffer();
-        externalCalls.push(buffer);
+        const call = new BytesWriter();
+        call.writeAddress(destinationContract);
+        call.writeBytesWithLength(calldata.getBuffer());
 
-        const response: Potential<Uint8Array> = this.getExternalCallResponse(
-            destinationContract,
-            externalCalls.length - 1,
-        );
-        if (!response) {
-            throw this.error('external call failed');
-        }
+        const response: Uint8Array = callContract(call.getBuffer());
 
-        return new BytesReader(response);*/
+        return new BytesReader(response);
+    }
 
-        throw this.error('Not implemented');
+    public log(data: string): void {
+        const writer = new BytesWriter();
+        writer.writeStringWithLength(data);
+
+        const buffer = writer.getBuffer();
+        log(buffer);
     }
 
     public addEvent(event: NetEvent): void {
@@ -221,10 +225,8 @@ export class BlockchainEnvironment {
         pointer: u16,
         keyPointer: MemorySlotPointer,
         value: MemorySlotData<u256>,
-        defaultValue: MemorySlotData<u256>,
     ): void {
         const pointerHash: u256 = encodePointerHash(pointer, keyPointer);
-        this.ensureStorageAtPointer(pointerHash, defaultValue);
 
         this._internalSetStorageAt(pointerHash, value);
     }
@@ -241,11 +243,6 @@ export class BlockchainEnvironment {
         return ABIRegistry.getWriteMethods();
     }
 
-    private purgeMemory(): void {
-        this.storage.clear();
-        this.events = [];
-    }
-
     private error(msg: string): Error {
         return new Error(`${BlockchainEnvironment.runtimeException}: ${msg}`);
     }
@@ -264,10 +261,6 @@ export class BlockchainEnvironment {
 
         this.storage.set(pointerHash, value);
 
-        if (u256.eq(value, u256.Zero)) {
-            return;
-        }
-
         const writer: BytesWriter = new BytesWriter();
         writer.writeU256(pointerHash);
         writer.writeU256(value);
@@ -305,6 +298,10 @@ export class BlockchainEnvironment {
         defaultValue: MemorySlotData<u256>,
     ): void {
         if (!this.hasPointerStorageHash(pointerHash)) {
+            if (u256.eq(defaultValue, u256.Zero)) {
+                return;
+            }
+
             this._internalSetStorageAt(pointerHash, defaultValue);
         }
     }

package/runtime/env/global.ts

@@ -17,3 +17,7 @@ export declare function deployFromAddress(data: Uint8Array): Uint8Array;
 // @ts-ignore
 @external('env', 'call')
 export declare function callContract(data: Uint8Array): Uint8Array;
+
+// @ts-ignore
+@external('env', 'log')
+export declare function log(data: Uint8Array): void;

package/runtime/index.ts

@@ -43,6 +43,7 @@ export * from './memory/MultiAddressMemoryMap';
 
 /** Storage */
 export * from './storage/StoredU256';
+export * from './storage/StoredString';
 
 /** Universal */
 export * from './universal/ABIRegistry';

package/runtime/memory/AddressMemoryMap.ts

@@ -17,7 +17,7 @@ export class AddressMemoryMap<K extends string, V extends MemorySlotData<u256>>
 
     public set(key: K, value: V): this {
         const keyHash: MemorySlotPointer = encodePointer(key);
-        Blockchain.setStorageAt(this.pointer, keyHash, value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, keyHash, value);
 
         return this;
     }

package/runtime/memory/KeyMerger.ts

@@ -24,7 +24,7 @@ export class KeyMerger<K extends string, K2 extends string, V extends MemorySlot
         const mergedKey: string = `${this.parentKey}${key2}`;
         const keyHash: MemorySlotPointer = encodePointer(mergedKey);
 
-        Blockchain.setStorageAt(this.pointer, keyHash, value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, keyHash, value);
 
         return this;
     }

package/runtime/storage/StoredString.ts

@@ -0,0 +1,145 @@
+import { u256 } from 'as-bignum/assembly';
+import { Blockchain } from '../env';
+import { SafeMath } from '../types/SafeMath';
+
+@final
+export class StoredString {
+    constructor(
+        public pointer: u16,
+        private defaultValue?: string,
+    ) {}
+
+    private _value: string = '';
+
+    @inline
+    public get value(): string {
+        if (!this._value) {
+            this.load();
+        }
+
+        return this._value;
+    }
+
+    @inline
+    public set value(value: string) {
+        this._value = value;
+        this.save();
+    }
+
+    private min(a: u32, b: u32): u32 {
+        return a < b ? a : b;
+    }
+
+    private max(a: u32, b: u32): u32 {
+        return a > b ? a : b;
+    }
+
+    private save(): void {
+        const length: u32 = this._value.length;
+        if (length == 0) {
+            return;
+        }
+
+        if (length > 2048) {
+            throw new Error('StoredString: value is too long');
+        }
+
+        // Prepare the header with the length of the string in the first 4 bytes
+        let header: u256 = u256.fromU32(length);
+        header = SafeMath.shl(header, 224);
+
+        let currentPointer: u256 = u256.Zero;
+        let remainingLength: u32 = length;
+        let offset: u32 = 0;
+
+        // Save the initial chunk (first 28 bytes) in the header
+        let bytesToWrite: u32 = this.min(remainingLength, 28);
+        header = this.saveChunk(header, this._value, offset, bytesToWrite, 4);
+        Blockchain.setStorageAt(this.pointer, currentPointer, header);
+
+        remainingLength -= bytesToWrite;
+        offset += bytesToWrite;
+
+        // Save the remaining chunks in subsequent storage slots
+        while (remainingLength > 0) {
+            bytesToWrite = this.min(remainingLength, 32);
+            let storageValue: u256 = this.saveChunk(
+                u256.Zero,
+                this._value,
+                offset,
+                bytesToWrite,
+                0,
+            );
+            currentPointer = u256.add(currentPointer, u256.One);
+            Blockchain.setStorageAt(this.pointer, currentPointer, storageValue);
+
+            remainingLength -= bytesToWrite;
+            offset += bytesToWrite;
+        }
+    }
+
+    // Helper method to save a chunk of the string into the storage slot
+    private saveChunk(
+        storage: u256,
+        value: string,
+        offset: u32,
+        length: u32,
+        storageOffset: u32,
+    ): u256 {
+        let bytes = storage.toBytes(true);
+        for (let i: u32 = 0; i < length; i++) {
+            let index: i32 = i32(offset + i);
+            bytes[i + storageOffset] = u8(value.charCodeAt(index));
+        }
+        return u256.fromBytes(bytes, true);
+    }
+
+    private load(): void {
+        const header: u256 = Blockchain.getStorageAt(this.pointer, u256.Zero, u256.Zero);
+        if (u256.eq(header, u256.Zero)) {
+            if (this.defaultValue) {
+                this.value = this.defaultValue;
+            }
+
+            return;
+        }
+
+        // the length of the string is stored in the first 4 bytes of the header
+        const bits: u256 = u256.shr(header, 224);
+        const length: u32 = bits.toU32();
+
+        // the rest contains the string itself
+        let currentPointer: u256 = u256.Zero;
+        let remainingLength: u32 = length;
+        let currentStorage: u256 = header;
+
+        let bytesToRead: u32 = this.min(remainingLength, 28);
+        let str: string = this.loadChunk(currentStorage, 4, bytesToRead);
+        remainingLength -= bytesToRead;
+
+        while (remainingLength > 0) {
+            // Move to the next storage slot
+            currentPointer = u256.add(currentPointer, u256.One);
+            currentStorage = Blockchain.getStorageAt(this.pointer, currentPointer, u256.Zero);
+
+            // Extract the relevant portion of the string from the current storage slot
+            let bytesToRead: u32 = this.min(remainingLength, 32);
+            str += this.loadChunk(currentStorage, 0, bytesToRead);
+
+            remainingLength -= bytesToRead;
+        }
+
+        this._value = str;
+    }
+
+    private loadChunk(value: u256, offset: u32, length: u32): string {
+        const bytes = value.toBytes(true);
+
+        let str: string = '';
+        for (let i: u32 = 0; i < length; i++) {
+            str += String.fromCharCode(bytes[i + offset]);
+        }
+
+        return str;
+    }
+}

package/runtime/storage/StoredU256.ts

@@ -9,9 +9,7 @@ export class StoredU256 {
         public pointer: u16,
         public subPointer: MemorySlotPointer,
         private defaultValue: u256,
-    ) {
-        this._value = Blockchain.getStorageAt(this.pointer, this.subPointer, this.defaultValue);
-    }
+    ) {}
 
     private _value: u256 = u256.Zero;
 
@@ -26,7 +24,7 @@ export class StoredU256 {
     public set value(value: u256) {
         this._value = value;
 
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
     }
 
     @inline
@@ -40,7 +38,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.add(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -51,7 +49,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.sub(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -62,7 +60,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.mul(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -121,7 +119,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.shr(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -132,7 +130,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.and(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -143,7 +141,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.or(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -154,7 +152,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.xor(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -176,7 +174,7 @@ export class StoredU256 {
             value = u256.shr(value, 1);
         }
 
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -201,7 +199,7 @@ export class StoredU256 {
         }
 
         this._value = result;
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -212,7 +210,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.add(this._value, u256.One);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -223,7 +221,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.sub(this._value, u256.One);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -232,7 +230,7 @@ export class StoredU256 {
     public set(value: u256): this {
         this._value = value;
 
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value, this.defaultValue);
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }

package/runtime/types/Address.ts

@@ -1,5 +1,5 @@
 import { Potential } from '../lang/Definitions';
 
-export const ADDRESS_BYTE_LENGTH: u8 = 64;
+export const ADDRESS_BYTE_LENGTH: u8 = 66;
 export declare type Address = string;
 export declare type PotentialAddress = Potential<Address>;

package/runtime/types/SafeMath.ts

@@ -19,6 +19,30 @@ export class SafeMath {
         return u256.sub(a, b);
     }
 
+    // Computes (a * b) % modulus with full precision
+    public static mulmod(a: u256, b: u256, modulus: u256): u256 {
+        if (u256.eq(modulus, u256.Zero)) throw new Error('SafeMath: modulo by zero');
+
+        const mul = SafeMath.mul(a, b);
+        return SafeMath.mod(mul, modulus);
+    }
+
+    @inline
+    @unsafe
+    @operator('%')
+    public static mod(a: u256, b: u256): u256 {
+        if (u256.eq(b, u256.Zero)) {
+            throw new Error('SafeMath: modulo by zero');
+        }
+
+        let result = a.clone();
+        while (u256.ge(result, b)) {
+            result = u256.sub(result, b);
+        }
+
+        return result;
+    }
+
     public static mul(a: u256, b: u256): u256 {
         if (a === SafeMath.ZERO || b === SafeMath.ZERO) {
             return SafeMath.ZERO;
@@ -37,7 +61,7 @@ export class SafeMath {
     @inline
     @unsafe
     @operator('/')
-    static div(a: u256, b: u256): u256 {
+    public static div(a: u256, b: u256): u256 {
         if (b.isZero()) {
             throw new Error('Division by zero');
         }
@@ -64,7 +88,7 @@ export class SafeMath {
         for (let i = shift; i >= 0; i--) {
             if (u256.ge(n, d)) {
                 n = u256.sub(n, d);
-                result = u256.or(result, SafeMath.shl(new u256(1), i));
+                result = u256.or(result, SafeMath.shl(u256.One, i));
             }
             d = u256.shr(d, 1); // restore d to original by shifting right
         }
@@ -86,16 +110,23 @@ export class SafeMath {
         if (u256.gt(y, u256.fromU32(3))) {
             let z = y;
 
-            let x = SafeMath.add(SafeMath.div(y, u256.fromU32(2)), u256.fromU32(1));
+            let u246_2 = u256.fromU32(2);
+
+            let 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);
-                x = SafeMath.div(u256.add(u, x), u256.fromU32(2));
+                let y2 = u256.add(u, x);
+
+                x = SafeMath.div(y2, u246_2);
             }
+
             return z;
         } else if (!u256.eq(y, u256.Zero)) {
-            return u256.fromU32(1);
+            return u256.One;
         } else {
             return u256.Zero;
         }
@@ -103,7 +134,7 @@ export class SafeMath {
 
     @inline
     @unsafe
-    static shl(value: u256, shift: i32): u256 {
+    public static shl(value: u256, shift: i32): u256 {
         if (shift == 0) {
             return value.clone();
         }