@btc-vision/btc-runtime 1.9.8 → 1.9.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.9.8",
+    "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);
@@ -284,6 +292,15 @@ export class BytesReader {
         return result;
     }
 
+    public readU8Array(be: boolean = true): u8[] {
+        const length = this.readU16(be);
+        const result = new Array<u8>(length);
+        for (let i: u16 = 0; i < length; i++) {
+            result[i] = this.readU8();
+        }
+        return result;
+    }
+
     public readU128Array(be: boolean = true): u128[] {
         const length = this.readU16(be);
         const result = new Array<u128>(length);

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,30 @@ 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(arrayTooLargeError);
+        this.allocSafe(U16_BYTE_LENGTH + value.length);
+        this.writeU16(u16(value.length), be);
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeU8(value[i]);
+        }
+    }
+
     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);
 
@@ -208,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);
 
@@ -218,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);
 
@@ -228,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);
 
@@ -238,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);
 
@@ -248,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/contracts/OP721.ts

@@ -24,7 +24,13 @@ import { IOP721 } from './interfaces/IOP721';
 import { OP721InitParameters } from './interfaces/OP721InitParameters';
 import { ReentrancyGuard } from './ReentrancyGuard';
 import { StoredMapU256 } from '../storage/maps/StoredMapU256';
-import { ApprovedEvent, ApprovedForAllEvent, MAX_URI_LENGTH, TransferredEvent, URIEvent, } from '../events/predefined';
+import {
+    ApprovedEvent,
+    ApprovedForAllEvent,
+    MAX_URI_LENGTH,
+    TransferredEvent,
+    URIEvent,
+} from '../events/predefined';
 import {
     ON_OP721_RECEIVED_SELECTOR,
     OP712_DOMAIN_TYPE_HASH,
@@ -251,6 +257,28 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
         return w;
     }
 
+    @method('changeMetadata')
+    public changeMetadata(calldata: Calldata): BytesWriter {
+        this.onlyDeployer(Blockchain.tx.sender);
+
+        const icon: string = calldata.readStringWithLength();
+        const banner: string = calldata.readStringWithLength();
+        const description: string = calldata.readStringWithLength();
+        const website: string = calldata.readStringWithLength();
+
+        if (icon.length == 0) throw new Revert('Icon cannot be empty');
+        if (banner.length == 0) throw new Revert('Banner cannot be empty');
+        if (description.length == 0) throw new Revert('Description cannot be empty');
+        if (website.length == 0) throw new Revert('Website cannot be empty');
+
+        this._collectionIcon.value = icon;
+        this._collectionBanner.value = banner;
+        this._collectionDescription.value = description;
+        this._collectionWebsite.value = website;
+
+        return new BytesWriter(0);
+    }
+
     @method('totalSupply')
     @returns({ name: 'totalSupply', type: ABIDataTypes.UINT256 })
     public fn_totalSupply(_: Calldata): BytesWriter {

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 {