@btc-vision/btc-runtime 1.1.4 → 1.1.5

package/package.json

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

package/runtime/buffer/BytesReader.ts

@@ -1,200 +1,200 @@
-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 {
-        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);
-                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`);
-        }
-    }
-
-    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();
-
-        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');
-        }
-    }
-}
+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 {
+        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);
+                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: u32 = 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`);
+        }
+    }
+
+    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();
+
+        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

@@ -9,6 +9,7 @@ import { cyrb53a } from '../math/cyrb53';
 import { Revert } from '../types/Revert';
 import { Map } from '../generic/Map';
 import { BlockchainStorage, PointerStorage } from '../types';
+import { ArrayBuffer } from 'arraybuffer';
 
 export enum BufferDataType {
     U8 = 0,
@@ -32,7 +33,9 @@ export class BytesWriter {
         length: i32 = 1,
         private readonly trackDataTypes: boolean = false,
     ) {
-        this.buffer = new DataView(new ArrayBuffer(length));
+        const arrayBuffer = new ArrayBuffer(length);
+
+        this.buffer = new DataView(arrayBuffer);
     }
 
     public bufferLength(): u32 {
@@ -239,11 +242,12 @@ export class BytesWriter {
         }
     }
 
-    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);
-        }
+    public getBuffer(clear: boolean = false): Uint8Array {
+        const buf = Uint8Array.wrap(
+            this.buffer.buffer,
+            this.buffer.byteOffset,
+            this.buffer.byteLength,
+        );
 
         if (clear) this.clear();
 

package/runtime/contracts/DeployableOP_20.ts

@@ -94,7 +94,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
             throw new Revert('Already initialized');
         }
 
-        if (!skipOwnerVerification) this.onlyOwner(Blockchain.origin);
+        if (!skipOwnerVerification) this.onlyOwner(Blockchain.txOrigin);
 
         if (params.decimals > 32) {
             throw new Revert('Decimals can not be more than 32');
@@ -117,15 +117,16 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     public approve(callData: Calldata): BytesWriter {
-        const response = new BytesWriter();
-
+        // Define the owner and spender
+        const owner = Blockchain.msgSender;
         const spender: Address = callData.readAddress();
         const value = callData.readU256();
 
-        const resp = this._approve(spender, value);
-        response.writeBoolean(resp);
+        // Response buffer
+        const response = new BytesWriter();
 
-        this.createApproveEvent(Blockchain.origin, spender, value);
+        const resp = this._approve(owner, spender, value);
+        response.writeBoolean(resp);
 
         return response;
     }
@@ -233,12 +234,16 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         return senderMap.get(spender);
     }
 
-    protected _approve(spender: Address, value: u256): boolean {
-        const callee = Blockchain.origin;
+    protected _approve(owner: Address, spender: Address, value: u256): boolean {
+        if (owner === Blockchain.DEAD_ADDRESS || spender === Blockchain.DEAD_ADDRESS) {
+            throw new Revert('Cannot approve from or to dead address');
+        }
 
-        const senderMap = this.allowanceMap.get(callee);
+        const senderMap = this.allowanceMap.get(owner);
         senderMap.set(spender, value);
 
+        this.createApproveEvent(owner, spender, value);
+
         return true;
     }
 
@@ -254,19 +259,16 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
             throw new Revert(`No tokens`);
         }
 
-        const callee = Blockchain.origin;
-        const caller = Blockchain.sender;
-
-        if (onlyOwner) this.onlyOwner(callee); // only indexers can burn tokens
+        if (onlyOwner) this.onlyOwner(Blockchain.txOrigin); // only indexers can burn tokens
 
         if (this._totalSupply.value < value) throw new Revert(`Insufficient total supply.`);
-        if (!this.balanceOfMap.has(caller)) throw new Revert('Empty');
+        if (!this.balanceOfMap.has(Blockchain.msgSender)) throw new Revert('No balance');
 
-        const balance: u256 = this.balanceOfMap.get(caller);
+        const balance: u256 = this.balanceOfMap.get(Blockchain.msgSender);
         if (balance < value) throw new Revert(`Insufficient balance`);
 
         const newBalance: u256 = SafeMath.sub(balance, value);
-        this.balanceOfMap.set(caller, newBalance);
+        this.balanceOfMap.set(Blockchain.msgSender, newBalance);
 
         // @ts-ignore
         this._totalSupply -= value;
@@ -276,9 +278,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     protected _mint(to: Address, value: u256, onlyOwner: boolean = true): boolean {
-        const callee = Blockchain.origin;
-
-        if (onlyOwner) this.onlyOwner(callee);
+        if (onlyOwner) this.onlyOwner(Blockchain.txOrigin);
 
         if (!this.balanceOfMap.has(to)) {
             this.balanceOfMap.set(to, value);
@@ -299,31 +299,27 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     protected _transfer(to: string, value: u256): boolean {
-        const caller = Blockchain.origin;
-
-        if (!this.balanceOfMap.has(caller)) throw new Revert();
-        if (this.isSelf(caller)) throw new Revert('Can not transfer from self account');
+        const sender = Blockchain.msgSender;
 
-        if (caller === to) {
-            throw new Revert(`Cannot transfer to self`);
-        }
+        if (!this.balanceOfMap.has(sender)) throw new Revert();
+        if (this.isSelf(sender)) throw new Revert('Can not transfer from self account');
 
         if (u256.eq(value, u256.Zero)) {
             throw new Revert(`Cannot transfer 0 tokens`);
         }
 
-        const balance: u256 = this.balanceOfMap.get(caller);
+        const balance: u256 = this.balanceOfMap.get(sender);
         if (balance < value) throw new Revert(`Insufficient balance`);
 
         const newBalance: u256 = SafeMath.sub(balance, value);
-        this.balanceOfMap.set(caller, newBalance);
+        this.balanceOfMap.set(sender, newBalance);
 
         const toBalance: u256 = this.balanceOfMap.get(to);
         const newToBalance: u256 = SafeMath.add(toBalance, value);
 
         this.balanceOfMap.set(to, newToBalance);
 
-        this.createTransferEvent(caller, to, value);
+        this.createTransferEvent(sender, to, value);
 
         return true;
     }
@@ -337,7 +333,6 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
             );
 
         const newBalance: u256 = SafeMath.sub(balance, value);
-
         this.balanceOfMap.set(from, newBalance);
 
         if (!this.balanceOfMap.has(to)) {
@@ -355,22 +350,30 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     protected _transferFrom(from: Address, to: Address, value: u256): boolean {
-        const spender = Blockchain.origin;
+        if (to === Blockchain.DEAD_ADDRESS || from === Blockchain.DEAD_ADDRESS) {
+            throw new Revert('Cannot transfer to or from dead address');
+        }
 
-        if (this.isSelf(spender)) throw new Revert('Can not transfer from self account');
+        this._spendAllowance(from, Blockchain.msgSender, value);
+        this._unsafeTransferFrom(from, to, value);
 
-        const fromAllowanceMap = this.allowanceMap.get(from);
-        const allowed: u256 = fromAllowanceMap.get(spender);
-        if (allowed < value) throw new Revert(`Insufficient allowance ${allowed} < ${value}`);
+        return true;
+    }
 
-        const newAllowance: u256 = SafeMath.sub(allowed, value);
-        fromAllowanceMap.set(spender, newAllowance);
+    protected _spendAllowance(owner: Address, spender: Address, value: u256): void {
+        const ownerAllowanceMap = this.allowanceMap.get(owner);
+        const allowed: u256 = ownerAllowanceMap.get(spender);
 
-        this.allowanceMap.set(from, fromAllowanceMap);
+        if (allowed < value) {
+            throw new Revert(
+                `Insufficient allowance ${allowed} < ${value}. Spender: ${spender} - Owner: ${owner}`,
+            );
+        }
 
-        this._unsafeTransferFrom(from, to, value);
+        const newAllowance: u256 = SafeMath.sub(allowed, value);
+        ownerAllowanceMap.set(spender, newAllowance);
 
-        return true;
+        this.allowanceMap.set(owner, ownerAllowanceMap);
     }
 
     protected createBurnEvent(value: u256): void {

package/runtime/env/BTCEnvironment.ts

@@ -28,7 +28,7 @@ export * from '../env/global';
 export class BlockchainEnvironment {
     private static readonly MAX_U16: u16 = 65535;
     private static readonly runtimeException: string = 'RuntimeException';
-
+    public readonly DEAD_ADDRESS: Address = 'bc1dead';
     private storage: PointerStorage = new MapU256();
     private events: NetEvent[] = [];
     private currentBlock: u256 = u256.Zero;
@@ -37,24 +37,24 @@ export class BlockchainEnvironment {
 
     constructor() {}
 
-    private _origin: PotentialAddress = null;
+    private _txOrigin: PotentialAddress = null;
 
-    public get origin(): Address {
-        if (!this._origin) {
+    public get txOrigin(): Address {
+        if (!this._txOrigin) {
             throw this.error('Callee is required');
         }
 
-        return this._origin as Address;
+        return this._txOrigin as Address;
     }
 
-    private _sender: PotentialAddress = null;
+    private _msgSender: PotentialAddress = null;
 
-    public get sender(): Address {
-        if (!this._sender) {
+    public get msgSender(): Address {
+        if (!this._msgSender) {
             throw this.error('Caller is required');
         }
 
-        return this._sender as Address;
+        return this._msgSender as Address;
     }
 
     private _timestamp: u64 = 0;
@@ -124,8 +124,8 @@ export class BlockchainEnvironment {
     public setEnvironment(data: Uint8Array): void {
         const reader: BytesReader = new BytesReader(data);
 
-        this._sender = reader.readAddress();
-        this._origin = reader.readAddress();
+        this._msgSender = reader.readAddress();
+        this._txOrigin = reader.readAddress(); // "leftmost thing in the call chain"
         this.currentBlock = reader.readU256();
 
         this._owner = reader.readAddress();
@@ -137,7 +137,7 @@ export class BlockchainEnvironment {
     }
 
     public call(destinationContract: Address, calldata: BytesWriter): BytesReader {
-        if (destinationContract === this._origin) {
+        if (destinationContract === this._contractAddress) {
             throw this.error('Cannot call self');
         }