@btc-vision/btc-runtime 1.0.15 → 1.0.16

package/package.json

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

package/runtime/buffer/BytesReader.ts

@@ -176,6 +176,17 @@ export class BytesReader {
         }
     }
 
+    public readAddressArray(): Address[] {
+        const length = this.readU16();
+        const result = new Array<Address>(length);
+
+        for (let i: u16 = 0; i < length; i++) {
+            result[i] = this.readAddress();
+        }
+
+        return result;
+    }
+
     private verifyChecksum(): void {
         const writtenChecksum = this.readU32();
 

package/runtime/buffer/BytesWriter.ts

@@ -70,6 +70,16 @@ export class BytesWriter {
         this.currentOffset += 8;
     }
 
+    public writeAddressArray(value: Address[]): void {
+        if (value.length > 65535) throw new Revert('Array size is too large');
+
+        this.writeU16(value.length);
+
+        for (let i: i32 = 0; i < value.length; i++) {
+            this.writeAddress(value[i]);
+        }
+    }
+
     public writeStorage(storage: BlockchainStorage): void {
         this.writeU32(storage.size);
 

package/runtime/contracts/OP_20.ts

@@ -14,14 +14,6 @@ import { MultiAddressMemoryMap } from '../memory/MultiAddressMemoryMap';
 import { StoredU256 } from '../storage/StoredU256';
 import { ApproveEvent, BurnEvent, MintEvent, TransferEvent } from '../events/predefined';
 
-const allowanceSelector = encodeSelector('allowance');
-const approveSelector = encodeSelector('approve');
-const balanceOfSelector = encodeSelector('balanceOf');
-const burnSelector = encodeSelector('burn');
-const mintSelector = encodeSelector('mint');
-const transferSelector = encodeSelector('transfer');
-const transferFromSelector = encodeSelector('transferFrom');
-
 export abstract class OP_20 extends OP_NET implements IOP_20 {
     protected readonly allowanceMap: MultiAddressMemoryMap<Address, Address, MemorySlotData<u256>>;
     protected readonly balanceOfMap: AddressMemoryMap<Address, MemorySlotData<u256>>;
@@ -128,19 +120,19 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
 
     public callMethod(method: Selector, calldata: Calldata): BytesWriter {
         switch (method) {
-            case allowanceSelector:
+            case encodeSelector('allowance'):
                 return this.allowance(calldata);
-            case approveSelector:
+            case encodeSelector('approve'):
                 return this.approve(calldata);
-            case balanceOfSelector:
+            case encodeSelector('balanceOf'):
                 return this.balanceOf(calldata);
-            case burnSelector:
+            case encodeSelector('burn'):
                 return this.burn(calldata);
-            case mintSelector:
+            case encodeSelector('mint'):
                 return this.mint(calldata);
-            case transferSelector:
+            case encodeSelector('transfer'):
                 return this.transfer(calldata);
-            case transferFromSelector:
+            case encodeSelector('transferFrom'):
                 return this.transferFrom(calldata);
             default:
                 return super.callMethod(method, calldata);
@@ -174,14 +166,13 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
     }
 
     /** REDEFINED METHODS */
-    protected _allowance(owner: string, spender: string): u256 {
+    protected _allowance(owner: Address, spender: Address): u256 {
         const senderMap = this.allowanceMap.get(owner);
-        if (!senderMap.has(spender)) throw new Revert();
 
         return senderMap.get(spender);
     }
 
-    protected _approve(spender: string, value: u256): boolean {
+    protected _approve(spender: Address, value: u256): boolean {
         const callee = Blockchain.callee();
 
         const senderMap = this.allowanceMap.get(callee);
@@ -225,10 +216,8 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
 
     protected _mint(to: Address, value: u256, onlyOwner: boolean = true): boolean {
         const callee = Blockchain.callee();
-        const caller = Blockchain.caller();
 
         if (onlyOwner) this.onlyOwner(callee);
-        if (caller !== callee) throw new Revert(`callee != caller`);
 
         if (!this.balanceOfMap.has(to)) {
             this.balanceOfMap.set(to, value);
@@ -305,27 +294,19 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
     }
 
     protected _transferFrom(from: Address, to: Address, value: u256): boolean {
-        if (!this.allowanceMap.has(from)) throw new Revert();
-
         const spender = Blockchain.callee();
         if (Blockchain.caller() !== from) {
             throw new Revert('Not caller.');
         }
 
-        const fromAllowanceMap = this.allowanceMap.get(from);
-        const allowed: u256 = fromAllowanceMap.get(spender);
-        if (allowed < value) throw new Revert(`Insufficient allowance`);
-
         if (this.isSelf(spender)) throw new Revert('Can not transfer from self account');
 
-        const senderMap = this.allowanceMap.get(from);
-        if (!senderMap.has(spender)) throw new Revert();
-
-        const allowance: u256 = senderMap.get(spender);
-        if (allowance < value) throw new Revert(`Insufficient allowance`);
+        const fromAllowanceMap = this.allowanceMap.get(from);
+        const allowed: u256 = fromAllowanceMap.get(spender);
+        if (allowed < value) throw new Revert(`Insufficient allowance ${allowed} < ${value}`);
 
-        const newAllowance: u256 = SafeMath.sub(allowance, value);
-        senderMap.set(spender, newAllowance);
+        const newAllowance: u256 = SafeMath.sub(allowed, value);
+        fromAllowanceMap.set(from, newAllowance);
 
         this._unsafeTransferFrom(from, to, value);
 

package/runtime/contracts/OP_NET.ts

@@ -7,10 +7,6 @@ import { encodeSelector, Selector } from '../math/abi';
 import { Revert } from '../types/Revert';
 import { MAX_EVENT_DATA_SIZE, NetEvent } from '../events/NetEvent';
 
-const isAddressOwnerSelector = encodeSelector('isAddressOwner');
-const addressSelector = encodeSelector('address');
-const ownerSelector = encodeSelector('owner');
-
 export class OP_NET implements IBTC {
     constructor() {}
 
@@ -24,7 +20,7 @@ export class OP_NET implements IBTC {
 
     public callMethod(method: Selector, calldata: Calldata): BytesWriter {
         switch (method) {
-            case isAddressOwnerSelector:
+            case encodeSelector('isAddressOwner'):
                 return this.isAddressOwner(calldata);
             default:
                 throw new Revert('Method not found');
@@ -35,10 +31,10 @@ export class OP_NET implements IBTC {
         const response = new BytesWriter();
 
         switch (method) {
-            case addressSelector:
+            case encodeSelector('address'):
                 response.writeAddress(this.address);
                 break;
-            case ownerSelector:
+            case encodeSelector('owner'):
                 response.writeAddress(this.owner);
                 break;
             default:

package/runtime/env/BTCEnvironment.ts

@@ -11,7 +11,15 @@ import { Potential } from '../lang/Definitions';
 import { Map } from '../generic/Map';
 import { OP_NET } from '../contracts/OP_NET';
 import { PointerStorage } from '../types';
-import { callContract, deploy, deployFromAddress, loadPointer, log, storePointer } from './global';
+import {
+    callContract,
+    deploy,
+    deployFromAddress,
+    encodeAddress,
+    loadPointer,
+    log,
+    storePointer,
+} from './global';
 import { DeployContractResponse } from '../interfaces/DeployContractResponse';
 
 export * from '../env/global';
@@ -119,6 +127,10 @@ export class BlockchainEnvironment {
             throw this.error('Cannot call self');
         }
 
+        if (!destinationContract) {
+            throw this.error('Destination contract is required');
+        }
+
         const call = new BytesWriter();
         call.writeAddress(destinationContract);
         call.writeBytesWithLength(calldata.getBuffer());
@@ -164,6 +176,18 @@ export class BlockchainEnvironment {
         return buffer.getBuffer();
     }
 
+    public encodeVirtualAddress(virtualAddress: Uint8Array): Address {
+        const writer: BytesWriter = new BytesWriter();
+        writer.writeBytesWithLength(virtualAddress);
+
+        const buffer: Uint8Array = writer.getBuffer();
+        const cb: Potential<Uint8Array> = encodeAddress(buffer);
+        if (!cb) throw this.error('Failed to encode virtual address');
+
+        const reader: BytesReader = new BytesReader(cb as Uint8Array);
+        return reader.readAddress();
+    }
+
     public deployContract(hash: u256, bytecode: Uint8Array): BytesReader {
         const writer = new BytesWriter();
         writer.writeU256(hash);

package/runtime/env/global.ts

@@ -21,3 +21,12 @@ export declare function callContract(data: Uint8Array): Uint8Array;
 // @ts-ignore
 @external('env', 'log')
 export declare function log(data: Uint8Array): void;
+
+// @ts-ignore
+@external('env', 'encodeAddress')
+export declare function encodeAddress(data: Uint8Array): Uint8Array;
+
+
+// @ts-ignore
+@external('env', 'sha256')
+export declare function sha256(data: Uint8Array): Uint8Array;

package/runtime/index.ts

@@ -47,3 +47,6 @@ export * from './storage/StoredString';
 
 /** Universal */
 export * from './universal/ABIRegistry';
+
+/** Shared libraries */
+export * from './shared-libraries/TransferHelper';

package/runtime/math/abi.ts

@@ -1,8 +1,8 @@
 // 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';
+import { Sha256 } from './sha256';
 
 export type Selector = u32;
 

package/runtime/math/sha256.ts

@@ -1,278 +1,12 @@
-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;
+import { sha256 } from '../env/global';
 
 export class Sha256 {
-    r: u64 = 0;
-    t: u64 = 0;
-    st: Uint8Array;
-
-    /**
-     * Initialize a multipart hash computation
-     * @returns A hash function state
-     */
-    constructor() {
-        this.st = Internal._hashInit();
-    }
-
-    /**
-     * 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);
-    }
-
-    /**
-     * Hash256
-     * @param {Uint8Array} m Message
-     * @returns {Uint8Array} `SHA-256(SHA-256(m))`
-     */
-    static hash256(m: Uint8Array): Uint8Array {
-        return Sha256.hash(Sha256.hash(m));
-    }
-
-    /**
-     * 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);
+    static hash(buffer: Uint8Array): Uint8Array {
+        return sha256(buffer);
     }
 
-    /**
-     * 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;
+    static hash256(buffer: Uint8Array): Uint8Array {
+        const hash = sha256(buffer);
+        return sha256(hash);
     }
 }

package/runtime/shared-libraries/TransferHelper.ts

@@ -0,0 +1,64 @@
+import { u256 } from 'as-bignum/assembly/integer/u256';
+import { encodeSelector, Selector } from '../math/abi';
+import { Address } from '../types/Address';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { Blockchain } from '../env';
+import { Revert } from '../types/Revert';
+
+export class TransferHelper {
+    public static get APPROVE_SELECTOR(): Selector {
+        return encodeSelector('approve');
+    }
+
+    public static get TRANSFER_SELECTOR(): Selector {
+        return encodeSelector('transfer');
+    }
+
+    public static get TRANSFER_FROM_SELECTOR(): Selector {
+        return encodeSelector('transferFrom');
+    }
+
+    public static safeApprove(token: Address, spender: Address, amount: u256): void {
+        const calldata = new BytesWriter();
+        calldata.writeSelector(this.APPROVE_SELECTOR);
+        calldata.writeAddress(spender);
+        calldata.writeU256(amount);
+
+        const response = Blockchain.call(token, calldata);
+        const isOk = response.readBoolean();
+
+        if (!isOk) {
+            throw new Revert(`TransferHelper: APPROVE_FAILED`);
+        }
+    }
+
+    public static safeTransfer(token: Address, to: Address, amount: u256): void {
+        const calldata = new BytesWriter();
+        calldata.writeSelector(this.TRANSFER_SELECTOR);
+        calldata.writeAddress(to);
+        calldata.writeU256(amount);
+
+        const response = Blockchain.call(token, calldata);
+        const isOk = response.readBoolean();
+
+        if (!isOk) {
+            throw new Revert(`TransferHelper: TRANSFER_FAILED`);
+        }
+    }
+
+    public static safeTransferFrom(token: Address, from: Address, to: Address, amount: u256): void {
+        const calldata = new BytesWriter();
+        calldata.writeSelector(this.TRANSFER_FROM_SELECTOR);
+
+        calldata.writeAddress(from);
+        calldata.writeAddress(to);
+        calldata.writeU256(amount);
+
+        const response = Blockchain.call(token, calldata);
+        const isOk = response.readBoolean();
+
+        if (!isOk) {
+            throw new Revert(`TransferHelper: TRANSFER_FROM_FAILED`);
+        }
+    }
+}