@btc-vision/btc-runtime 1.9.9 → 1.9.10

package/package.json

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

package/runtime/buffer/BytesReader.ts

@@ -203,8 +203,7 @@ export class BytesReader {
     }
 
     /**
-     * [u32 length][raw bytes]. By default big-endian for the length,
-     * to match AS BytesWriter's `writeBytesWithLength`.
+     * [u32 length][raw bytes]. By default big-endian for the length
      */
     public readBytesWithLength(be: boolean = true): Uint8Array {
         const length = this.readU32(be);
@@ -248,8 +247,17 @@ export class BytesReader {
 
     // ------------------- Arrays ------------------- //
 
+    public readArrayOfBuffer(be: boolean = true): Uint8Array[] {
+        const length = this.readU16(be);
+        const result: Uint8Array[] = new Array<Uint8Array>(length);
+        for (let i: u32 = 0; i < length; i++) {
+            result[i] = this.readBytesWithLength();
+        }
+        return result;
+    }
+
     public readU256Array(be: boolean = true): u256[] {
-        const length = this.readU16();
+        const length = this.readU16(be);
         const result = new Array<u256>(length);
         for (let i: u32 = 0; i < length; i++) {
             result[i] = this.readU256(be);

package/runtime/buffer/BytesWriter.ts

@@ -19,6 +19,8 @@ import {
 } from '../utils';
 import { BytesReader } from './BytesReader';
 
+const arrayTooLargeError: string = 'Array is too large';
+
 @final
 export class BytesWriter {
     private currentOffset: u32 = 0;
@@ -30,6 +32,17 @@ export class BytesWriter {
         this.buffer = new DataView(typedArray.buffer);
     }
 
+    public static estimateArrayOfBufferLength(values: Uint8Array[]): u32 {
+        if (values.length > 65535) throw new Revert(arrayTooLargeError);
+        let totalLength: u32 = U16_BYTE_LENGTH;
+
+        for (let i = 0; i < values.length; i++) {
+            totalLength += U32_BYTE_LENGTH + u32(values[i].length); // each entry has a u32 length prefix
+        }
+
+        return totalLength;
+    }
+
     public bufferLength(): u32 {
         return this.buffer.byteLength;
     }
@@ -197,8 +210,20 @@ export class BytesWriter {
 
     // ------------------ Array Writers ------------------ //
 
+    public writeArrayOfBuffer(values: Uint8Array[], be: boolean = true): void {
+        const totalLength = BytesWriter.estimateArrayOfBufferLength(values);
+
+        this.allocSafe(totalLength);
+        this.writeU16(u16(values.length), be);
+
+        for (let i = 0; i < values.length; i++) {
+            this.writeU32(u32(values[i].length), be);
+            this.writeBytes(values[i]);
+        }
+    }
+
     public writeU8Array(value: u8[], be: boolean = true): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.allocSafe(U16_BYTE_LENGTH + value.length);
         this.writeU16(u16(value.length), be);
 
@@ -208,7 +233,7 @@ export class BytesWriter {
     }
 
     public writeU16Array(value: u16[], be: boolean = true): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.allocSafe(U16_BYTE_LENGTH + value.length * U16_BYTE_LENGTH);
         this.writeU16(u16(value.length), be);
 
@@ -218,7 +243,7 @@ export class BytesWriter {
     }
 
     public writeU32Array(value: u32[], be: boolean = true): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.allocSafe(U16_BYTE_LENGTH + value.length * U32_BYTE_LENGTH);
         this.writeU16(u16(value.length), be);
 
@@ -228,7 +253,7 @@ export class BytesWriter {
     }
 
     public writeU64Array(value: u64[], be: boolean = true): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.allocSafe(U16_BYTE_LENGTH + value.length * U64_BYTE_LENGTH);
         this.writeU16(u16(value.length), be);
 
@@ -238,7 +263,7 @@ export class BytesWriter {
     }
 
     public writeU128Array(value: u128[], be: boolean = true): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.allocSafe(U16_BYTE_LENGTH + value.length * U128_BYTE_LENGTH);
         this.writeU16(u16(value.length), be);
 
@@ -248,7 +273,7 @@ export class BytesWriter {
     }
 
     public writeU256Array(value: u256[], be: boolean = true): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.allocSafe(U16_BYTE_LENGTH + value.length * U256_BYTE_LENGTH);
         this.writeU16(u16(value.length), be);
 
@@ -258,7 +283,7 @@ export class BytesWriter {
     }
 
     public writeAddressArray(value: Address[]): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.writeU16(u16(value.length));
 
         for (let i: i32 = 0; i < value.length; i++) {

package/runtime/env/classes/UTXO.ts

@@ -7,12 +7,17 @@ export class TransactionInput {
         public readonly txId: Uint8Array,
         public readonly outputIndex: u16,
         public readonly scriptSig: Uint8Array,
+        public readonly witnesses: Uint8Array[] | null,
         public readonly coinbase: Uint8Array | null,
     ) {}
 
     public get isCoinbase(): boolean {
         return (this.flags & TransactionInputFlags.hasCoinbase) !== 0;
     }
+
+    public get hasWitnesses(): boolean {
+        return (this.flags & TransactionInputFlags.hasWitnesses) !== 0;
+    }
 }
 
 @final

package/runtime/env/decoders/TransactionDecoder.ts

@@ -35,7 +35,14 @@ export class TransactionDecoder {
             ? buffer.readBytesWithLength()
             : null;
 
-        return new TransactionInput(flags, txId, outputIndex, scriptSig, coinbase);
+        const witnesses: Uint8Array[] | null = this.hasFlag(
+            flags,
+            TransactionInputFlags.hasWitnesses,
+        )
+            ? buffer.readArrayOfBuffer()
+            : null;
+
+        return new TransactionInput(flags, txId, outputIndex, scriptSig, witnesses, coinbase);
     }
 
     private decodeOutput(buffer: BytesReader): TransactionOutput {

package/runtime/env/enums/TransactionFlags.ts

@@ -1,5 +1,6 @@
 export enum TransactionInputFlags {
     hasCoinbase = 0b00000001,
+    hasWitnesses = 0b00000010,
 }
 
 export enum TransactionOutputFlags {