@btc-vision/btc-runtime 1.0.0

package/runtime/index.ts

@@ -0,0 +1,45 @@
+/** Environment */
+export * from './env';
+
+/** Contracts */
+export * from './contracts/interfaces/IOP_20';
+export * from './contracts/OP_20';
+export * from './contracts/OP_NET';
+
+/** Buffer */
+export * from './buffer/BytesReader';
+export * from './buffer/BytesWriter';
+
+/** Events */
+export * from './events/NetEvent';
+export * from './events/predefined';
+
+/** Types */
+export * from './generic/Map';
+export * from './interfaces/IBTC';
+
+/** Definitions */
+export * from './lang/Definitions';
+export * from './types/Address';
+export * from './types/Revert';
+export * from './types/SafeMath';
+
+/** Math */
+export * from './math/abi';
+export * from './math/bytes';
+export * from './math/cyrb53';
+export * from './math/sha256';
+export * from './math/rnd';
+
+/** Memory */
+export * from './memory/AddressMemoryMap';
+export * from './memory/MemorySlot';
+export * from './memory/MemorySlotPointer';
+export * from './memory/KeyMerger';
+export * from './memory/MultiAddressMemoryMap';
+
+/** Storage */
+export * from './storage/StoredU256';
+
+/** Universal */
+export * from './universal/ABIRegistry';

package/runtime/interfaces/IBTC.ts

@@ -0,0 +1,6 @@
+import { Address } from '../types/Address';
+
+export interface IBTC {
+    readonly owner: Address;
+    readonly address: Address;
+}

package/runtime/lang/Definitions.ts

@@ -0,0 +1 @@
+export type Potential<T> = T | null;

package/runtime/math/abi.ts

@@ -0,0 +1,37 @@
+// SO IN TYPESCRIPT, WE CAN NOT USE TWO METHOD WITH THE SAME NAME. SO NOT ADDING THE TYPE TO THE HASH IS A DESIGN CHOICE.
+import { bytes32, bytes4 } from './bytes';
+import { Sha256 } from './sha256';
+import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { u256 } from 'as-bignum/assembly';
+
+export type Selector = u32;
+
+export function encodeSelector(name: string): Selector {
+    const typed = Uint8Array.wrap(String.UTF8.encode(name));
+    const hash = Sha256.hash(typed);
+
+    return bytes4(hash);
+}
+
+export function encodePointer(str: string): MemorySlotPointer {
+    const typed = Uint8Array.wrap(String.UTF8.encode(str));
+    const hash = Sha256.hash(typed);
+
+    return bytes32(hash);
+}
+
+export function encodePointerHash(pointer: u16, sub: u256): MemorySlotPointer {
+    const finalBuffer: Uint8Array = new Uint8Array(34);
+    const mergedKey: u8[] = [u8(pointer & u16(0xff)), u8((pointer >> u16(8)) & u16(0xff))];
+
+    for (let i: i32 = 0; i < mergedKey.length; i++) {
+        finalBuffer[i] = mergedKey[i];
+    }
+
+    const subKey = sub.toUint8Array();
+    for (let i: i32 = 0; i < subKey.length; i++) {
+        finalBuffer[mergedKey.length + i] = subKey[i];
+    }
+
+    return bytes32(Sha256.hash(finalBuffer));
+}

package/runtime/math/bytes.ts

@@ -0,0 +1,34 @@
+import { u256 } from 'as-bignum/assembly';
+
+export function bytes(number: u256[]): Uint8Array {
+    const result = new Uint8Array(32 * number.length);
+    for (let i: u8 = 0; i < 32; i++) {
+        const num: Uint8Array = number[31 - i].toUint8Array();
+        for (let j: u8 = 0; j < u8(number.length); j++) {
+            result[i + j * 32] = num[i];
+        }
+    }
+
+    return result;
+}
+
+export function bytes4(number: Uint8Array): u32 {
+    return (u32(number[0]) << 24) | (u32(number[1]) << 16) | (u32(number[2]) << 8) | u32(number[3]);
+}
+
+export function bytes8(number: Uint8Array): u64 {
+    return (
+        (u64(number[0]) << u64(56)) |
+        (u64(number[1]) << u64(48)) |
+        (u64(number[2]) << u64(40)) |
+        (u64(number[3]) << u64(32)) |
+        (u64(number[4]) << 24) |
+        (u64(number[5]) << 16) |
+        (u64(number[6]) << 8) |
+        u64(number[7])
+    );
+}
+
+export function bytes32(number: Uint8Array): u256 {
+    return u256.fromBytes(number);
+}

package/runtime/math/cyrb53.ts

@@ -0,0 +1,46 @@
+export function cyrb53(str: string, seed: i32 = 0): i64 {
+    let h1: i32 = 0xdeadbeef ^ seed;
+    let h2: i32 = 0x41c6ce57 ^ seed;
+    for (let i: i32 = 0; i < str.length; i++) {
+        let ch: i32 = str.charCodeAt(i);
+        h1 = (h1 ^ ch) * 2654435761;
+        h2 = (h2 ^ ch) * 1597334677;
+    }
+
+    h1 = ((h1 ^ (h1 >>> 16)) * 2246822507) ^ ((h2 ^ (h2 >>> 13)) * 3266489909);
+    h2 = ((h2 ^ (h2 >>> 16)) * 2246822507) ^ ((h1 ^ (h1 >>> 13)) * 3266489909);
+
+    return 4294967296 * i64((2097151 & h2) >>> 0) + i64(h1 >>> 0);
+}
+
+export function imul64(a: u64, b: u64): u64 {
+    const aLow: u64 = a & 0xffffffff;
+    const aHigh: u64 = a >> 32;
+    const bLow: u64 = b & 0xffffffff;
+    const bHigh: u64 = b >> 32;
+
+    const low: u64 = aLow * bLow;
+    const middle1: u64 = (aHigh * bLow) << 32;
+    const middle2: u64 = (aLow * bHigh) << 32;
+    const high: u64 = (aHigh * bHigh) << 64;
+
+    return low + middle1 + middle2 + high;
+}
+
+export function cyrb53a(str: u8[], seed: i32 = 0): u64 {
+    let h1: u64 = u64(0xdeadbeef ^ seed);
+    let h2: u64 = u64(0x41c6ce57 ^ seed);
+
+    for (let i: i32 = 0; i < str.length; i++) {
+        let ch: u64 = u64(str[i]);
+        h1 = imul64(h1 ^ ch, 0x85ebca77);
+        h2 = imul64(h2 ^ ch, 0xc2b2ae3d);
+    }
+
+    h1 ^= imul64(h1 ^ (h2 >> 15), 0x735a2d97);
+    h2 ^= imul64(h2 ^ (h1 >> 15), 0xcaf649a9);
+    h1 ^= h2 >> 16;
+    h2 ^= h1 >> 16;
+
+    return (2097152 * (h2 & 0xffffffffffffffff) + (h1 >> 11)) & 0xffffffffffffffff;
+}

package/runtime/math/rnd.ts

@@ -0,0 +1,51 @@
+let random_state0_64: u64;
+let random_state1_64: u64;
+let random_state0_32: u32;
+let random_state1_32: u32;
+let random_seeded = false;
+
+function murmurHash3(h: u64): u64 {
+    // Force all bits of a hash block to avalanche
+    h ^= h >> 33; // see: https://github.com/aappleby/smhasher
+    h *= 0xff51afd7ed558ccd;
+    h ^= h >> 33;
+    h *= 0xc4ceb9fe1a85ec53;
+    h ^= h >> 33;
+    return h;
+}
+
+function splitMix32(h: u32): u32 {
+    h += 0x6d2b79f5;
+    h = (h ^ (h >> 15)) * (h | 1);
+    h ^= h + (h ^ (h >> 7)) * (h | 61);
+    return h ^ (h >> 14);
+}
+
+function seedRandom(value: i64): void {
+    // Instead zero seed use golden ratio:
+    // phi = (1 + sqrt(5)) / 2
+    // trunc(2^64 / phi) = 0x9e3779b97f4a7c15
+    if (value == 0) value = 0x9e3779b97f4a7c15;
+    random_state0_64 = murmurHash3(value);
+    random_state1_64 = murmurHash3(~random_state0_64);
+    random_state0_32 = splitMix32(<u32>value);
+    random_state1_32 = splitMix32(random_state0_32);
+    random_seeded = true;
+}
+
+/**
+ * Safe deterministic random number generator
+ * @param {u64} seed - The seed to use
+ */
+export function randomU64(seed: i64): u64 {
+    if (!random_seeded) seedRandom(seed);
+    let s1 = random_state0_64;
+    let s0 = random_state1_64;
+    random_state0_64 = s0;
+    s1 ^= s1 << 23;
+    s1 ^= s1 >> 17;
+    s1 ^= s0;
+    s1 ^= s0 >> 26;
+    random_state1_64 = s1;
+    return s0;
+}

package/runtime/math/sha256.ts

@@ -0,0 +1,270 @@
+type aisize = i32;
+
+function setU8(t: Uint8Array, s: Uint8Array, o: isize = 0): void {
+    memory.copy(t.dataStart + o, s.dataStart, s.length);
+}
+
+function store64_be(x: Uint8Array, offset: isize, u: u64): void {
+    store<u64>(changetype<usize>(x.buffer) + offset, bswap(u));
+}
+
+function load32_be(x: Uint8Array, offset: isize): u32 {
+    return bswap(load<u32>(changetype<usize>(x.buffer) + offset));
+}
+
+function store32_be(x: Uint8Array, offset: isize, u: u32): void {
+    store<u32>(changetype<usize>(x.buffer) + offset, bswap(u));
+}
+
+class Internal {
+    static K: u32[] = [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4,
+        0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe,
+        0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f,
+        0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+        0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
+        0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+        0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116,
+        0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7,
+        0xc67178f2,
+    ];
+    static iv: u8[] = [
+        0x6a, 0x09, 0xe6, 0x67, 0xbb, 0x67, 0xae, 0x85, 0x3c, 0x6e, 0xf3, 0x72, 0xa5, 0x4f, 0xf5,
+        0x3a, 0x51, 0x0e, 0x52, 0x7f, 0x9b, 0x05, 0x68, 0x8c, 0x1f, 0x83, 0xd9, 0xab, 0x5b, 0xe0,
+        0xcd, 0x19,
+    ];
+
+    @inline
+    static Sigma0(x: u32): u32 {
+        return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22);
+    }
+
+    @inline
+    static Sigma1(x: u32): u32 {
+        return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25);
+    }
+
+    @inline
+    static sigma0(x: u32): u32 {
+        return rotr(x, 7) ^ rotr(x, 18) ^ (x >> 3);
+    }
+
+    @inline
+    static sigma1(x: u32): u32 {
+        return rotr(x, 17) ^ rotr(x, 19) ^ (x >> 10);
+    }
+
+    @inline
+    static Ch(x: u32, y: u32, z: u32): u32 {
+        return z ^ (x & (y ^ z));
+    }
+
+    @inline
+    static Maj(x: u32, y: u32, z: u32): u32 {
+        return (x & (y ^ z)) ^ (y & z);
+    }
+
+    static expand(w: StaticArray<u32>): void {
+        for (let i = 0; i < 16; i++) {
+            unchecked(
+                (w[i] +=
+                    w[(i + 9) & 15] +
+                    Internal.sigma1(w[(i + 14) & 15]) +
+                    Internal.sigma0(w[(i + 1) & 15])),
+            );
+        }
+    }
+
+    static handle(r: StaticArray<u32>, w: StaticArray<u32>, c: u32[]): void {
+        for (let i = 0; i < 16; i++) {
+            var x = r[7 & (7 - i)] + w[i] + c[i];
+            x += unchecked(Internal.Sigma1(r[7 & (4 - i)]));
+            x += unchecked(Internal.Ch(r[7 & (4 - i)], r[7 & (5 - i)], r[7 & (6 - i)]));
+            unchecked((r[7 & (3 - i)] += x));
+            x += unchecked(Internal.Sigma0(r[7 & (0 - i)]));
+            x += unchecked(Internal.Maj(r[7 & (0 - i)], r[7 & (1 - i)], r[7 & (2 - i)]));
+            unchecked((r[7 & (7 - i)] = x));
+        }
+    }
+
+    static _hashblocks(st: Uint8Array, m: Uint8Array, n_: isize): isize {
+        let z = new StaticArray<u32>(8),
+            r = new StaticArray<u32>(8),
+            w = new StaticArray<u32>(16);
+        for (let i = 0; i < 8; ++i) {
+            unchecked((z[i] = r[i] = load32_be(st, i << 2)));
+        }
+        let pos = 0,
+            n = n_;
+        while (n >= 64) {
+            for (let i = 0; i < 16; ++i) {
+                w[i] = load32_be(m, (i << 2) + pos);
+            }
+            Internal.handle(r, w, Internal.K.slice(0));
+            Internal.expand(w);
+            Internal.handle(r, w, Internal.K.slice(16));
+            Internal.expand(w);
+            Internal.handle(r, w, Internal.K.slice(32));
+            Internal.expand(w);
+            Internal.handle(r, w, Internal.K.slice(48));
+            for (let i = 0; i < 8; ++i) {
+                let x = unchecked(r[i] + z[i]);
+                unchecked((z[i] = x));
+                unchecked((r[i] = x));
+            }
+            pos += 64;
+            n -= 64;
+        }
+        for (let i = 0; i < 8; ++i) {
+            store32_be(st, i << 2, unchecked(z[i]));
+        }
+        return n;
+    }
+
+    static _hashInit(): Uint8Array {
+        let st = new Uint8Array(32 + 64);
+
+        for (let i = 0; i < 32; ++i) {
+            st[i] = Internal.iv[i];
+        }
+        return st;
+    }
+
+    static _hashUpdate(st: Uint8Array, m: Uint8Array, n: isize, r: isize): isize {
+        let obuffered = st.subarray(32);
+        let buffered = new Uint8Array(64);
+        setU8(buffered, obuffered.subarray(0, 64));
+
+        let still_available_in_buffer = <isize>64 - r;
+        let copiable_to_buffer = min(n, still_available_in_buffer);
+        setU8(buffered, m.subarray(0, <aisize>copiable_to_buffer), r);
+        r += copiable_to_buffer;
+        n -= copiable_to_buffer;
+        let pos: isize = 0;
+        if (r === 64) {
+            Internal._hashblocks(st, buffered, 64);
+            r = 0;
+            pos = copiable_to_buffer;
+        }
+        if (n == 0) {
+            setU8(obuffered, buffered);
+            return r;
+        }
+        let left = m.subarray(<aisize>pos);
+        r = Internal._hashblocks(st, left, left.length);
+        if (r > 0) {
+            setU8(obuffered, left.subarray(left.length - <aisize>r));
+        }
+        return r;
+    }
+
+    static _hashFinal(st: Uint8Array, out: Uint8Array, t: isize, r: isize): void {
+        let buffered = st.subarray(32);
+        let padded = new Uint8Array(128);
+        setU8(padded, buffered.subarray(0, <aisize>r));
+        padded[<aisize>r] = 0x80;
+        if (r < 56) {
+            store64_be(padded, 64 - 8, t << 3);
+            Internal._hashblocks(st, padded, 64);
+        } else {
+            store64_be(padded, 128 - 8, t << 3);
+            Internal._hashblocks(st, padded, 128);
+        }
+        for (let i = 0; i < 32; ++i) {
+            out[i] = st[i];
+        }
+    }
+
+    static _hash(out: Uint8Array, m: Uint8Array, n: isize): void {
+        let st = Internal._hashInit();
+        let r = Internal._hashUpdate(st, m, n, 0);
+
+        Internal._hashFinal(st, out, n, r);
+    }
+
+    static _hmac(m: Uint8Array, k: Uint8Array): Uint8Array {
+        if (k.length > 64) {
+            k = Sha256.hash(k);
+        }
+        let b = new Uint8Array(64);
+        setU8(b, k);
+        for (let i = 0; i < b.length; ++i) {
+            b[i] ^= 0x36;
+        }
+        let out = new Uint8Array(32);
+        let st = Internal._hashInit();
+        let r = Internal._hashUpdate(st, b, b.length, 0);
+        r = Internal._hashUpdate(st, m, m.length, r);
+        Internal._hashFinal(st, out, b.length + m.length, r);
+        for (let i = 0; i < b.length; ++i) {
+            b[i] ^= 0x6a;
+        }
+        st = Internal._hashInit();
+        r = Internal._hashUpdate(st, b, b.length, 0);
+        r = Internal._hashUpdate(st, out, out.length, r);
+        Internal._hashFinal(st, out, b.length + out.length, r);
+        return out;
+    }
+}
+
+/**
+ * Hash function output size, in bytes
+ */
+export const SHA256_HASH_BYTES: isize = 32;
+
+export class Sha256 {
+    r: u64 = 0;
+    t: u64 = 0;
+    st: Uint8Array;
+
+    /**
+     * Initialize a multipart hash computation
+     * @returns A hash function state
+     */
+    constructor() {
+        let st = Internal._hashInit();
+        this.st = st;
+    }
+
+    /**
+     * Compute a hash for a single-part message
+     * @param m Message
+     * @returns Hash
+     */
+    static hash(m: Uint8Array): Uint8Array {
+        let h = new Uint8Array(<aisize>SHA256_HASH_BYTES);
+        Internal._hash(h, m, m.length);
+        return h;
+    }
+
+    /**
+     * HMAC-SHA-256
+     * @param m Message
+     * @param k Key
+     * @returns `HMAC-SHA-256(m, k)`
+     */
+    static hmac(m: Uint8Array, k: Uint8Array): Uint8Array {
+        return Internal._hmac(m, k);
+    }
+
+    /**
+     * Absorb data to be hashed
+     * @param m (partial) message
+     */
+    update(m: Uint8Array): void {
+        let n = m.length;
+        this.t += n;
+        this.r = Internal._hashUpdate(this.st, m, n, this.r as isize);
+    }
+
+    /**
+     * Finalize a hash computation
+     * @returns Hash
+     */
+    final(): Uint8Array {
+        let h = new Uint8Array(<aisize>SHA256_HASH_BYTES);
+        Internal._hashFinal(this.st, h, this.t as isize, this.r as isize);
+        return h;
+    }
+}

package/runtime/memory/AddressMemoryMap.ts

@@ -0,0 +1,64 @@
+import { MemorySlotPointer } from './MemorySlotPointer';
+import { Blockchain } from '../env';
+import { Address } from '../types/Address';
+import { encodePointer } from '../math/abi';
+import { MemorySlotData } from './MemorySlot';
+import { u256 } from 'as-bignum/assembly';
+
+@final
+export class AddressMemoryMap<K extends string, V extends MemorySlotData<u256>> {
+    public pointer: u16;
+
+    private readonly memoryAllocatorAddress: Address;
+
+    constructor(
+        pointer: u16,
+        self: Address,
+        private readonly defaultValue: V,
+    ) {
+        this.pointer = pointer;
+        this.memoryAllocatorAddress = self;
+    }
+
+    public set(key: K, value: V): this {
+        const keyHash: MemorySlotPointer = encodePointer(key);
+        Blockchain.setStorageAt(
+            this.memoryAllocatorAddress,
+            this.pointer,
+            keyHash,
+            value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    public get(key: K): MemorySlotData<u256> {
+        return Blockchain.getStorageAt(
+            this.memoryAllocatorAddress,
+            this.pointer,
+            encodePointer(key),
+            this.defaultValue,
+        );
+    }
+
+    public has(key: K): bool {
+        return Blockchain.hasStorageAt(
+            this.memoryAllocatorAddress,
+            this.pointer,
+            encodePointer(key),
+        );
+    }
+
+    @unsafe
+    public delete(key: K): bool {
+        this.set(key, this.defaultValue);
+
+        return true;
+    }
+
+    @unsafe
+    public clear(): void {
+        throw new Error('Method not implemented.');
+    }
+}

package/runtime/memory/KeyMerger.ts

@@ -0,0 +1,72 @@
+import { MemorySlotData } from './MemorySlot';
+import { u256 } from 'as-bignum/assembly';
+import { Blockchain } from '../env';
+import { Address } from '../types/Address';
+import { MemorySlotPointer } from './MemorySlotPointer';
+import { encodePointer } from '../math/abi';
+
+@final
+export class KeyMerger<K extends string, K2 extends string, V extends MemorySlotData<u256>> {
+    public parentKey: K;
+
+    public pointer: u16;
+    private readonly memoryAllocatorAddress: Address;
+
+    constructor(
+        parent: K,
+        pointer: u16,
+        self: Address,
+        private readonly defaultValue: V,
+    ) {
+        this.pointer = pointer;
+        this.memoryAllocatorAddress = self;
+
+        this.parentKey = parent;
+    }
+
+    public set(key2: K2, value: V): this {
+        const mergedKey: string = `${this.parentKey}${key2}`;
+        const keyHash: MemorySlotPointer = encodePointer(mergedKey);
+
+        Blockchain.setStorageAt(
+            this.memoryAllocatorAddress,
+            this.pointer,
+            keyHash,
+            value,
+            this.defaultValue,
+        );
+
+        return this;
+    }
+
+    public get(key: K): MemorySlotData<u256> {
+        const mergedKey: string = `${this.parentKey}${key}`;
+
+        return Blockchain.getStorageAt(
+            this.memoryAllocatorAddress,
+            this.pointer,
+            encodePointer(mergedKey),
+            this.defaultValue,
+        );
+    }
+
+    public has(key: K): bool {
+        const mergedKey: string = `${this.parentKey}${key}`;
+
+        return Blockchain.hasStorageAt(
+            this.memoryAllocatorAddress,
+            this.pointer,
+            encodePointer(mergedKey),
+        );
+    }
+
+    @unsafe
+    public delete(_key: K): bool {
+        throw new Error('Method not implemented.');
+    }
+
+    @unsafe
+    public clear(): void {
+        throw new Error('Clear method not implemented.');
+    }
+}

package/runtime/memory/MemorySlot.ts

@@ -0,0 +1 @@
+export type MemorySlotData<T> = T;

package/runtime/memory/MemorySlotPointer.ts

@@ -0,0 +1,3 @@
+import { u256 } from 'as-bignum/assembly';
+
+export type MemorySlotPointer = u256;