@btc-vision/btc-runtime 1.6.2 → 1.7.0

package/README.md

@@ -132,9 +132,9 @@ export class MyToken extends DeployableOP_20 {
 
     public override execute(method: Selector, calldata: Calldata): BytesWriter {
         switch (method) {
-            case encodeSelector('airdrop'):
+            case encodeSelector('airdrop()'):
                 return this.airdrop(calldata);
-            case encodeSelector('airdropWithAmount'):
+            case encodeSelector('airdropWithAmount()'):
                 return this.airdropWithAmount(calldata);
             default:
                 return super.execute(method, calldata);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.6.2",
+    "version": "1.7.0",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "scripts": {},

package/runtime/buffer/BytesReader.ts

@@ -1,5 +1,4 @@
 import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
-import { TransactionInput, TransactionOutput } from '../env/classes/UTXO';
 import { AddressMap } from '../generic/AddressMap';
 import { Selector } from '../math/abi';
 import { Address } from '../types/Address';
@@ -207,7 +206,7 @@ export class BytesReader {
      * Reads a string of `length` raw bytes, zeroStop = true for convenience.
      * (Or the writer may not have used zeroStop.)
      */
-    public readString(length: u16): string {
+    public readString(length: u32): string {
         const bytes = this.readBytes(length, true);
         return String.UTF8.decode(bytes.buffer);
     }
@@ -217,7 +216,7 @@ export class BytesReader {
      * The AS writer calls `writeStringWithLength(value: string)` => writes length big-endian by default.
      */
     public readStringWithLength(be: boolean = true): string {
-        const length = this.readU16(be);
+        const length = this.readU32(be);
         return this.readString(length);
     }
 
@@ -242,7 +241,7 @@ export class BytesReader {
         return addr;
     }
 
-// ------------------- Arrays ------------------- //
+    // ------------------- Arrays ------------------- //
 
     /**
      * The AS writer does `writeU32(length)` for U256 arrays, so we read a u32.
@@ -330,34 +329,6 @@ export class BytesReader {
         return result;
     }
 
-    public readTransactionInputs(): TransactionInput[] {
-        const length = this.readU16();
-        const result = new Array<TransactionInput>(length);
-
-        for (let i: u16 = 0; i < length; i++) {
-            const txId = this.readBytes(32);
-            const outputIndex = this.readU16();
-            const scriptSig = this.readBytesWithLength();
-            result[i] = new TransactionInput(txId, outputIndex, scriptSig);
-        }
-
-        return result;
-    }
-
-    public readTransactionOutputs(): TransactionOutput[] {
-        const length = this.readU16();
-        const result = new Array<TransactionOutput>(length);
-
-        for (let i: u16 = 0; i < length; i++) {
-            const index = this.readU16();
-            const scriptPubKey = this.readStringWithLength();
-            const value = this.readU64();
-            result[i] = new TransactionOutput(index, scriptPubKey, value);
-        }
-
-        return result;
-    }
-
     public getOffset(): i32 {
         return this.currentOffset;
     }
@@ -373,7 +344,7 @@ export class BytesReader {
         if (size > this.buffer.byteLength) {
             throw new Error(
                 `Attempt to read beyond buffer length. Requested up to offset ${size}, ` +
-                `but buffer is only ${this.buffer.byteLength} bytes.`,
+                    `but buffer is only ${this.buffer.byteLength} bytes.`,
             );
         }
     }

package/runtime/buffer/BytesWriter.ts

@@ -286,7 +286,7 @@ export class BytesWriter {
     }
 
     public writeStringWithLength(value: string): void {
-        this.writeU16(u16(value.length));
+        this.writeU32(u32(value.length));
         this.writeString(value);
     }
 
@@ -352,8 +352,8 @@ export class BytesWriter {
     private resize(size: u32): void {
         throw new Revert(
             `Buffer is getting resized. This is bad for performance. ` +
-            `Expected size: ${this.buffer.byteLength + size} - ` +
-            `Current size: ${this.buffer.byteLength}`,
+                `Expected size: ${this.buffer.byteLength + size} - ` +
+                `Current size: ${this.buffer.byteLength}`,
         );
     }
 }

package/runtime/contracts/DeployableOP_20.ts

@@ -205,23 +205,23 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         let response: BytesWriter;
 
         switch (method) {
-            case encodeSelector('decimals'):
+            case encodeSelector('decimals()'):
                 response = new BytesWriter(BOOLEAN_BYTE_LENGTH);
                 response.writeU8(this.decimals);
                 break;
-            case encodeSelector('name'):
+            case encodeSelector('name()'):
                 response = new BytesWriter(this.name.length + 2);
                 response.writeStringWithLength(this.name);
                 break;
-            case encodeSelector('symbol'):
+            case encodeSelector('symbol()'):
                 response = new BytesWriter(this.symbol.length + 2);
                 response.writeStringWithLength(this.symbol);
                 break;
-            case encodeSelector('totalSupply'):
+            case encodeSelector('totalSupply()'):
                 response = new BytesWriter(U256_BYTE_LENGTH);
                 response.writeU256(this.totalSupply);
                 break;
-            case encodeSelector('maximumSupply'):
+            case encodeSelector('maximumSupply()'):
                 response = new BytesWriter(U256_BYTE_LENGTH);
                 response.writeU256(this.maxSupply);
                 break;

package/runtime/contracts/OP_NET.ts

@@ -27,7 +27,7 @@ export class OP_NET implements IBTC {
         let response: BytesWriter;
 
         switch (method) {
-            case encodeSelector('deployer'):
+            case encodeSelector('deployer()'):
                 response = new BytesWriter(ADDRESS_BYTE_LENGTH);
                 response.writeAddress(this.contractDeployer);
                 break;

package/runtime/env/BlockchainEnvironment.ts

@@ -35,8 +35,6 @@ export * from '../env/global';
 
 @final
 export class BlockchainEnvironment {
-    private static readonly MAX_U16: u16 = 65535;
-
     public readonly DEAD_ADDRESS: Address = Address.dead();
 
     private storage: MapUint8Array = new MapUint8Array();
@@ -81,7 +79,7 @@ export class BlockchainEnvironment {
     private _nextPointer: u16 = 0;
 
     public get nextPointer(): u16 {
-        if (this._nextPointer === BlockchainEnvironment.MAX_U16) {
+        if (this._nextPointer === u16.MAX_VALUE) {
             throw new Revert(`Out of storage pointer.`);
         }
 
@@ -157,12 +155,7 @@ export class BlockchainEnvironment {
         const caller = reader.readAddress();
         const origin = reader.readAddress();
 
-        this._tx = new Transaction(
-            caller,
-            origin,
-            txId,
-            txHash,
-        );
+        this._tx = new Transaction(caller, origin, txId, txHash);
 
         this._contractDeployer = contractDeployer;
         this._contractAddress = contractAddress;
@@ -178,7 +171,12 @@ export class BlockchainEnvironment {
         }
 
         const resultLengthBuffer = new ArrayBuffer(32);
-        const status = callContract(destinationContract.buffer, calldata.getBuffer().buffer, calldata.bufferLength(), resultLengthBuffer);
+        const status = callContract(
+            destinationContract.buffer,
+            calldata.getBuffer().buffer,
+            calldata.bufferLength(),
+            resultLengthBuffer,
+        );
 
         const reader = new BytesReader(Uint8Array.wrap(resultLengthBuffer));
         const resultLength = reader.readU32(true);
@@ -244,9 +242,7 @@ export class BlockchainEnvironment {
         return contractAddressReader.readAddress();
     }
 
-    public getStorageAt(
-        pointerHash: Uint8Array,
-    ): Uint8Array {
+    public getStorageAt(pointerHash: Uint8Array): Uint8Array {
         this.hasPointerStorageHash(pointerHash);
         if (this.storage.has(pointerHash)) {
             return this.storage.get(pointerHash);
@@ -255,9 +251,7 @@ export class BlockchainEnvironment {
         return new Uint8Array(32);
     }
 
-    public getTransientStorageAt(
-        pointerHash: Uint8Array,
-    ): Uint8Array {
+    public getTransientStorageAt(pointerHash: Uint8Array): Uint8Array {
         if (this.hasPointerTransientStorageHash(pointerHash)) {
             return this.transientStorage.get(pointerHash);
         }

package/runtime/env/classes/Transaction.ts

@@ -3,16 +3,18 @@ import { TransactionInput, TransactionOutput } from './UTXO';
 import { Potential } from '../../lang/Definitions';
 import { BytesReader } from '../../buffer/BytesReader';
 import { getInputsSize, getOutputsSize, inputs, outputs } from '../global';
+import { TransactionDecoder } from '../decoders/TransactionDecoder';
 
 @final
 export class Transaction {
+    private readonly transactionDecoder: TransactionDecoder = new TransactionDecoder();
+
     public constructor(
         public readonly sender: Address, // "immediate caller"
         public readonly origin: Address, // "leftmost thing in the call chain"
         public readonly txId: Uint8Array,
         public readonly hash: Uint8Array,
-    ) {
-    }
+    ) {}
 
     private _inputs: Potential<TransactionInput[]> = null;
 
@@ -46,7 +48,7 @@ export class Transaction {
         inputs(resultBuffer);
 
         const reader = new BytesReader(Uint8Array.wrap(resultBuffer));
-        return reader.readTransactionInputs();
+        return this.transactionDecoder.readTransactionInputs(reader);
     }
 
     private loadOutputs(): TransactionOutput[] {
@@ -55,6 +57,6 @@ export class Transaction {
         outputs(resultBuffer);
 
         const reader = new BytesReader(Uint8Array.wrap(resultBuffer));
-        return reader.readTransactionOutputs();
+        return this.transactionDecoder.readTransactionOutputs(reader);
     }
 }

package/runtime/env/classes/UTXO.ts

@@ -1,10 +1,17 @@
+import { TransactionInputFlags, TransactionOutputFlags } from '../enums/TransactionFlags';
+
 @final
 export class TransactionInput {
     public constructor(
+        public readonly flags: u8,
         public readonly txId: Uint8Array,
         public readonly outputIndex: u16,
         public readonly scriptSig: Uint8Array,
-    ) {
+        public readonly coinbase: Uint8Array | null,
+    ) {}
+
+    public get isCoinbase(): boolean {
+        return (this.flags & TransactionInputFlags.hasCoinbase) !== 0;
     }
 }
 
@@ -12,8 +19,21 @@ export class TransactionInput {
 export class TransactionOutput {
     public constructor(
         public readonly index: u16,
-        public readonly to: string,
+        public readonly flags: u8,
+        public readonly scriptPublicKey: Uint8Array | null,
+        public readonly to: string | null,
         public readonly value: u64,
-    ) {
+    ) {}
+
+    public get hasTo(): boolean {
+        return (this.flags & TransactionOutputFlags.hasTo) !== 0;
+    }
+
+    public get hasScriptPubKey(): boolean {
+        return (this.flags & TransactionOutputFlags.hasScriptPubKey) !== 0;
+    }
+
+    public get isOPReturn(): boolean {
+        return (this.flags & TransactionOutputFlags.OP_RETURN) !== 0;
     }
 }

package/runtime/env/decoders/TransactionDecoder.ts

@@ -0,0 +1,66 @@
+import { TransactionInput, TransactionOutput } from '../classes/UTXO';
+import { TransactionInputFlags, TransactionOutputFlags } from '../enums/TransactionFlags';
+import { BytesReader } from '../../buffer/BytesReader';
+
+export class TransactionDecoder {
+    public readTransactionInputs(buffer: BytesReader): TransactionInput[] {
+        const length = buffer.readU16();
+        const result = new Array<TransactionInput>(length);
+
+        for (let i: u16 = 0; i < length; i++) {
+            result[i] = this.decodeInput(buffer);
+        }
+
+        return result;
+    }
+
+    public readTransactionOutputs(buffer: BytesReader): TransactionOutput[] {
+        const length = buffer.readU16();
+        const result = new Array<TransactionOutput>(length);
+
+        for (let i: u16 = 0; i < length; i++) {
+            result[i] = this.decodeOutput(buffer);
+        }
+
+        return result;
+    }
+
+    private decodeInput(buffer: BytesReader): TransactionInput {
+        const flags = buffer.readU8();
+        const txId = buffer.readBytes(32);
+        const outputIndex = buffer.readU16();
+        const scriptSig = buffer.readBytesWithLength();
+
+        const coinbase: Uint8Array | null = this.hasFlag(flags, TransactionInputFlags.hasCoinbase)
+            ? buffer.readBytesWithLength()
+            : null;
+
+        return new TransactionInput(flags, txId, outputIndex, scriptSig, coinbase);
+    }
+
+    private decodeOutput(buffer: BytesReader): TransactionOutput {
+        const flags = buffer.readU8();
+        const index = buffer.readU16();
+
+        let scriptPubKey: Uint8Array | null = null;
+        if (this.hasFlag(flags, TransactionOutputFlags.hasScriptPubKey)) {
+            scriptPubKey = buffer.readBytesWithLength();
+        }
+
+        let to: string | null = null;
+        if (this.hasFlag(flags, TransactionOutputFlags.hasTo)) {
+            to = buffer.readStringWithLength();
+        }
+
+        const value = buffer.readU64();
+
+        return new TransactionOutput(index, flags, scriptPubKey, to, value);
+    }
+
+    /**
+     * Checks if the given flag is set in the flags byte.
+     */
+    private hasFlag<T extends u8>(flags: u8, flag: T): boolean {
+        return (flags & flag) !== 0;
+    }
+}

package/runtime/env/enums/TransactionFlags.ts

@@ -0,0 +1,9 @@
+export enum TransactionInputFlags {
+    hasCoinbase = 0b00000001,
+}
+
+export enum TransactionOutputFlags {
+    hasTo = 0b00000001,
+    hasScriptPubKey = 0b00000010,
+    OP_RETURN = 0b00000100,
+}