@btc-vision/btc-runtime 1.0.0

package/runtime/memory/MultiAddressMemoryMap.ts

@@ -0,0 +1,76 @@
+import { Address } from '../types/Address';
+import { MemorySlotData } from './MemorySlot';
+import { u256 } from 'as-bignum/assembly';
+import { KeyMerger } from './KeyMerger';
+import { Map } from '../generic/Map';
+
+@final
+export class MultiAddressMemoryMap<
+    K extends string,
+    K2 extends string,
+    V extends MemorySlotData<u256>,
+> extends Map<K, KeyMerger<K, K2, V>> {
+    public pointer: u16;
+
+    private readonly memoryAllocatorAddress: Address;
+
+    constructor(
+        pointer: u16,
+        self: Address,
+        private readonly defaultValue: V,
+    ) {
+        super();
+
+        this.pointer = pointer;
+        this.memoryAllocatorAddress = self;
+    }
+
+    public get(key: K): KeyMerger<K, K2, V> {
+        this.createKeyMerger(key);
+
+        return super.get(key);
+    }
+
+    public setUpperKey(key: K, key2: K2, value: V): this {
+        this.createKeyMerger(key);
+
+        const subMap = super.get(key);
+        if (subMap) {
+            subMap.set(key2, value);
+        }
+
+        return this;
+    }
+
+    public set(key: K, value: KeyMerger<K, K2, V>): this {
+        this.createKeyMerger(key);
+
+        return <this>(<unknown>super.set(key, value));
+    }
+
+    public has(key: K): bool {
+        return super.has(key);
+    }
+
+    public delete(key: K): bool {
+        return super.delete(key);
+    }
+
+    public clear(): void {
+        super.clear();
+    }
+
+    private createKeyMerger(key: K): void {
+        if (!super.has(key)) {
+            super.set(
+                key,
+                new KeyMerger<K, K2, V>(
+                    key,
+                    this.pointer,
+                    this.memoryAllocatorAddress,
+                    this.defaultValue,
+                ),
+            );
+        }
+    }
+}

package/runtime/storage/StoredU256.ts

@@ -0,0 +1,320 @@
+import { u256 } from 'as-bignum/assembly';
+import { SafeMath } from '../types/SafeMath';
+import { Address } from '../types/Address';
+import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { Blockchain } from '../env';
+
+@final
+export class StoredU256 {
+    constructor(
+        public address: Address,
+        public pointer: u16,
+        public subPointer: MemorySlotPointer,
+        private defaultValue: u256,
+    ) {
+        this._value = Blockchain.getStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this.defaultValue,
+        );
+    }
+
+    private _value: u256 = u256.Zero;
+
+    @inline
+    public get value(): u256 {
+        this.ensureValue();
+
+        return this._value;
+    }
+
+    @inline
+    @operator('+')
+    public add(value: u256): this {
+        this.ensureValue();
+
+        this._value = SafeMath.add(this._value, value);
+        Blockchain.setStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this._value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    @inline
+    @operator('-')
+    public sub(value: u256): this {
+        this.ensureValue();
+
+        this._value = SafeMath.sub(this._value, value);
+        Blockchain.setStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this._value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    @inline
+    @operator('*')
+    public mul(value: u256): this {
+        this.ensureValue();
+
+        this._value = SafeMath.mul(this._value, value);
+        Blockchain.setStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this._value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    @inline
+    @operator('==')
+    public eq(value: u256): boolean {
+        this.ensureValue();
+
+        return this._value === value;
+    }
+
+    @inline
+    @operator('!=')
+    public ne(value: u256): boolean {
+        this.ensureValue();
+
+        return this._value !== value;
+    }
+
+    @inline
+    @operator('<')
+    public lt(value: u256): boolean {
+        this.ensureValue();
+
+        return this._value < value;
+    }
+
+    @inline
+    @operator('>')
+    public gt(value: u256): boolean {
+        this.ensureValue();
+
+        return this._value > value;
+    }
+
+    @inline
+    @operator('<=')
+    public le(value: u256): boolean {
+        this.ensureValue();
+
+        return this._value <= value;
+    }
+
+    @inline
+    @operator('>=')
+    public ge(value: u256): boolean {
+        this.ensureValue();
+
+        return this._value >= value;
+    }
+
+    @inline
+    @operator('>>')
+    public shr(value: i32): this {
+        this.ensureValue();
+
+        this._value = u256.shr(this._value, value);
+        Blockchain.setStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this._value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    @inline
+    @operator('&')
+    public and(value: u256): this {
+        this.ensureValue();
+
+        this._value = u256.and(this._value, value);
+        Blockchain.setStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this._value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    @inline
+    @operator('|')
+    public or(value: u256): this {
+        this.ensureValue();
+
+        this._value = u256.or(this._value, value);
+        Blockchain.setStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this._value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    @inline
+    @operator('^')
+    public xor(value: u256): this {
+        this.ensureValue();
+
+        this._value = u256.xor(this._value, value);
+        Blockchain.setStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this._value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    @inline
+    @operator('**')
+    public pow(value: u256): this {
+        this.ensureValue();
+
+        // code pow from scratch
+        let result: u256 = u256.One;
+
+        while (value > u256.Zero) {
+            if (u256.and(value, u256.One)) {
+                result = SafeMath.mul(result, this._value);
+            }
+
+            this._value = SafeMath.mul(this._value, this._value);
+            value = u256.shr(value, 1);
+        }
+
+        Blockchain.setStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this._value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    @inline
+    @operator('%')
+    public mod(value: u256): this {
+        this.ensureValue();
+
+        // code mod from scratch
+        let result: u256 = u256.Zero;
+        let base: u256 = this._value;
+        let exp: u256 = value;
+
+        while (exp > u256.Zero) {
+            if (u256.and(exp, u256.One)) {
+                result = SafeMath.add(result, base);
+            }
+
+            base = SafeMath.add(base, base);
+            exp = u256.shr(exp, 1);
+        }
+
+        this._value = result;
+        Blockchain.setStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this._value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    @inline
+    @operator.postfix('++')
+    public inc(): this {
+        this.ensureValue();
+
+        this._value = SafeMath.add(this._value, u256.One);
+        Blockchain.setStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this._value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    @inline
+    @operator.postfix('--')
+    public dec(): this {
+        this.ensureValue();
+
+        this._value = SafeMath.sub(this._value, u256.One);
+        Blockchain.setStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this._value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    @inline
+    public set(value: u256): this {
+        this._value = value;
+
+        Blockchain.setStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this._value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    @inline
+    public toUint8Array(): Uint8Array {
+        return this._value.toUint8Array(true);
+    }
+
+    private ensureValue(): void {
+        this._value = Blockchain.getStorageAt(
+            this.address,
+            this.pointer,
+            this.subPointer,
+            this.defaultValue,
+        );
+    }
+}

package/runtime/types/Address.ts

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

package/runtime/types/Revert.ts

@@ -0,0 +1,5 @@
+export class Revert extends Error {
+    constructor(msg: string = '') {
+        super(`Execution reverted ${msg}`);
+    }
+}

package/runtime/types/SafeMath.ts

@@ -0,0 +1,137 @@
+import { u256 } from 'as-bignum/assembly';
+
+export class SafeMath {
+    public static ZERO: u256 = u256.fromU32(0);
+
+    public static add(a: u256, b: u256): u256 {
+        const c: u256 = u256.add(a, b);
+        if (c < a) {
+            throw new Error('SafeMath: addition overflow');
+        }
+        return c;
+    }
+
+    public static sub(a: u256, b: u256): u256 {
+        if (a < b) {
+            throw new Error('SafeMath: subtraction overflow');
+        }
+
+        return u256.sub(a, b);
+    }
+
+    public static mul(a: u256, b: u256): u256 {
+        if (a === SafeMath.ZERO || b === SafeMath.ZERO) {
+            return SafeMath.ZERO;
+        }
+
+        const c: u256 = u256.mul(a, b);
+        const d: u256 = SafeMath.div(c, a);
+
+        if (u256.ne(d, b)) {
+            throw new Error('SafeMath: multiplication overflow');
+        }
+
+        return c;
+    }
+
+    @inline
+    @unsafe
+    @operator('/')
+    static div(a: u256, b: u256): u256 {
+        if (b.isZero()) {
+            throw new Error('Division by zero');
+        }
+
+        if (a.isZero()) {
+            return new u256();
+        }
+
+        if (u256.lt(a, b)) {
+            return new u256(); // Return 0 if a < b
+        }
+
+        if (u256.eq(a, b)) {
+            return new u256(1); // Return 1 if a == b
+        }
+
+        let n = a.clone();
+        let d = b.clone();
+        let result = new u256();
+
+        let shift = u256.clz(d) - u256.clz(n);
+        d = SafeMath.shl(d, shift); // align d with n by shifting left
+
+        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));
+            }
+            d = u256.shr(d, 1); // restore d to original by shifting right
+        }
+
+        return result;
+    }
+
+    @inline
+    @unsafe
+    static shl(value: u256, shift: i32): u256 {
+        if (shift == 0) {
+            return value.clone();
+        }
+
+        let totalBits = 256;
+        let bitsPerSegment = 64;
+
+        // Normalize shift to be within 0-255 range
+        shift &= 255;
+
+        if (shift >= totalBits) {
+            return new u256(); // Shift size larger than width results in zero
+        }
+
+        // Determine how many full 64-bit segments we are shifting
+        let segmentShift = (shift / bitsPerSegment) | 0;
+        let bitShift = shift % bitsPerSegment;
+
+        let segments = [value.lo1, value.lo2, value.hi1, value.hi2];
+
+        let result = new Array<u64>(4).fill(0);
+
+        for (let i = 0; i < segments.length; i++) {
+            if (i + segmentShift < segments.length) {
+                result[i + segmentShift] |= segments[i] << bitShift;
+            }
+            if (bitShift != 0 && i + segmentShift + 1 < segments.length) {
+                result[i + segmentShift + 1] |= segments[i] >>> (bitsPerSegment - bitShift);
+            }
+        }
+
+        return new u256(result[0], result[1], result[2], result[3]);
+    }
+
+    public static and(a: u256, b: u256): u256 {
+        return u256.and(a, b);
+    }
+
+    public static or(a: u256, b: u256): u256 {
+        return u256.or(a, b);
+    }
+
+    public static xor(a: u256, b: u256): u256 {
+        return u256.xor(a, b);
+    }
+
+    public static shr(a: u256, b: u32): u256 {
+        return u256.shr(a, b);
+    }
+
+    /**
+     * Increment a u256 value by 1
+     * @param value The value to increment
+     * @returns The incremented value
+     */
+    @inline
+    static inc(value: u256): u256 {
+        return value.preInc();
+    }
+}

package/runtime/types/index.ts

@@ -0,0 +1,8 @@
+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';
+
+export type PointerStorage = Map<MemorySlotPointer, MemorySlotData<u256>>;
+export type BlockchainStorage = Map<Address, PointerStorage>;

package/runtime/universal/ABIRegistry.ts

@@ -0,0 +1,72 @@
+import { encodeSelector, Selector } from '../math/abi';
+import { BytesReader } from '../buffer/BytesReader';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { Map } from '../generic/Map';
+
+export type Calldata = NonNullable<BytesReader>;
+export type SelectorsMap = Map<u32, Uint8Array>;
+
+class ABIRegistryBase {
+    private methodMap: Selector[] = [];
+    private selectors: SelectorsMap = new Map();
+
+    private viewSelectors: Selector[] = [];
+    private allowedWriteMethods: Selector[] = [];
+
+    // Register properties with their selectors and handlers
+    public defineGetterSelector(name: string, canWrite: boolean): void {
+        const selector: Selector = encodeSelector(name);
+
+        const selectorWriter: BytesWriter = new BytesWriter();
+        selectorWriter.writeABISelector(name, selector);
+
+        if (!this.selectors.has(selector)) {
+            this.selectors.set(selector, selectorWriter.getBuffer());
+        }
+
+        if (canWrite) this.addToWriteMethods(selector);
+
+        if (!this.viewSelectors.includes(selector)) {
+            this.viewSelectors.push(selector);
+        }
+    }
+
+    public getViewSelectors(): Uint8Array {
+        const writer: BytesWriter = new BytesWriter();
+        writer.writeViewSelectorMap(this.selectors);
+
+        return writer.getBuffer();
+    }
+
+    public getMethodSelectors(): Uint8Array {
+        const writer: BytesWriter = new BytesWriter();
+        writer.writeMethodSelectorsMap(this.methodMap);
+
+        return writer.getBuffer();
+    }
+
+    public getWriteMethods(): Uint8Array {
+        const writer: BytesWriter = new BytesWriter();
+        writer.writeMethodSelectorsMap(this.allowedWriteMethods);
+
+        return writer.getBuffer();
+    }
+
+    // Register methods with their selectors and handlers
+    public defineMethodSelector(name: string, canWrite: boolean): void {
+        const selector: u32 = encodeSelector(name);
+        if (canWrite) this.addToWriteMethods(selector);
+
+        if (!this.methodMap.includes(selector)) {
+            this.methodMap.push(selector);
+        }
+    }
+
+    private addToWriteMethods(selector: Selector): void {
+        if (!this.allowedWriteMethods.includes(selector)) {
+            this.allowedWriteMethods.push(selector);
+        }
+    }
+}
+
+export const ABIRegistry = new ABIRegistryBase();