@btc-vision/transaction 1.8.0-beta.3 → 1.8.0-beta.4

package/src/transaction/builders/MultiSignTransaction.ts

@@ -1,34 +1,41 @@
 import {
     crypto as bitcoinCrypto,
+    equals,
+    fromHex,
     opcodes,
-    P2TRPayment,
+    type P2TRPayment,
     PaymentType,
     Psbt,
-    PsbtInput,
-    PsbtInputExtended,
-    PsbtOutputExtended,
+    type PsbtInput,
+    type PsbtInputExtended,
+    type PsbtOutputExtended,
+    type PublicKey,
+    type Script,
     script,
-    Signer,
-    TapScriptSig,
-    Taptree,
+    type Signer,
+    type TapScriptSig,
+    type Taptree,
+    toHex,
+    toSatoshi,
     toXOnly,
 } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
-import { ITransactionParameters } from '../interfaces/ITransactionParameters.js';
+import type { UpdateInput } from '../interfaces/Tap.js';
+import type { ITransactionParameters } from '../interfaces/ITransactionParameters.js';
 import { MultiSignGenerator } from '../../generators/builders/MultiSignGenerator.js';
-import { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import type { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
-import { ECPairInterface } from 'ecpair';
+import { type UniversalSigner } from '@btc-vision/ecpair';
 
 export interface MultiSignParameters extends Omit<
     ITransactionParameters,
-    'gasSatFee' | 'priorityFee' | 'signer'
+    'gasSatFee' | 'priorityFee' | 'signer' | 'from' | 'to'
 > {
-    readonly pubkeys: Buffer[];
+    readonly pubkeys: Uint8Array[];
     readonly minimumSignatures: number;
-    readonly from?: undefined;
-    readonly to?: undefined;
+    readonly from?: string | undefined;
+    readonly to?: string | undefined;
     readonly psbt?: Psbt;
     readonly receiver: string;
     readonly requestedAmount: bigint;
@@ -44,7 +51,7 @@ export interface MultiSignFromBase64Params extends Omit<MultiSignParameters, 'ps
  * @class MultiSignTransaction
  */
 export class MultiSignTransaction extends TransactionBuilder<TransactionType.MULTI_SIG> {
-    public static readonly LOCK_LEAF_SCRIPT: Buffer = script.compile([
+    public static readonly LOCK_LEAF_SCRIPT: Script = script.compile([
         opcodes.OP_XOR,
         opcodes.OP_NOP,
         opcodes.OP_CODESEPARATOR,
@@ -54,20 +61,19 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
         //Transaction.SIGHASH_ALL,
         //Transaction.SIGHASH_ANYONECANPAY,
     ];
-    public static readonly numsPoint = Buffer.from(
+    public static readonly numsPoint: PublicKey = fromHex(
         '50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0',
-        'hex',
-    );
+    ) as PublicKey;
 
     public type: TransactionType.MULTI_SIG = TransactionType.MULTI_SIG;
 
     protected targetScriptRedeem: P2TRPayment | null = null;
     protected leftOverFundsScriptRedeem: P2TRPayment | null = null;
 
-    protected readonly compiledTargetScript: Buffer;
+    protected readonly compiledTargetScript: Uint8Array;
     protected readonly scriptTree: Taptree;
 
-    protected readonly publicKeys: Buffer[];
+    protected readonly publicKeys: Uint8Array[];
     protected readonly minimumSignatures: number;
 
     protected readonly originalInputCount: number = 0;
@@ -79,7 +85,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
      * @description Sign hash types
      * @protected
      */
-    protected readonly sighashTypes: number[] = MultiSignTransaction.signHashTypesArray;
+    protected override readonly sighashTypes: number[] = MultiSignTransaction.signHashTypesArray;
 
     public constructor(parameters: MultiSignParameters) {
         if (!parameters.refundVault) {
@@ -97,11 +103,11 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
         super({
             ...parameters,
             signer: EcKeyPair.fromPrivateKey(
-                bitcoinCrypto.sha256(Buffer.from('aaaaaaaa', 'utf-8')),
+                bitcoinCrypto.sha256(new TextEncoder().encode('aaaaaaaa')),
             ),
             priorityFee: 0n,
             gasSatFee: 0n,
-        });
+        } as ITransactionParameters);
 
         if (!parameters.pubkeys) {
             throw new Error('Pubkeys are required');
@@ -149,10 +155,10 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
      * @param {Buffer} signerPubKey The signer public key
      * @returns {boolean} True if the public key signed the transaction
      */
-    public static verifyIfSigned(psbt: Psbt, signerPubKey: Buffer): boolean {
+    public static verifyIfSigned(psbt: Psbt, signerPubKey: Uint8Array): boolean {
         let alreadySigned: boolean = false;
         for (let i = 1; i < psbt.data.inputs.length; i++) {
-            const input: PsbtInput = psbt.data.inputs[i];
+            const input: PsbtInput = psbt.data.inputs[i] as PsbtInput;
             if (!input.finalScriptWitness) {
                 continue;
             }
@@ -166,9 +172,9 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
             }
 
             for (let j = 0; j < decoded.length - 2; j += 3) {
-                const pubKey = decoded[j + 2];
+                const pubKey = decoded[j + 2] as Uint8Array;
 
-                if (pubKey.equals(signerPubKey)) {
+                if (equals(pubKey, signerPubKey)) {
                     alreadySigned = true;
                     break;
                 }
@@ -185,7 +191,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
      */
     public static signPartial(
         psbt: Psbt,
-        signer: Signer | ECPairInterface,
+        signer: Signer | UniversalSigner,
         originalInputCount: number,
         minimums: number[],
     ): {
@@ -196,7 +202,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
         let final: boolean = true;
 
         for (let i = originalInputCount; i < psbt.data.inputs.length; i++) {
-            const input: PsbtInput = psbt.data.inputs[i];
+            const input: PsbtInput = psbt.data.inputs[i] as PsbtInput;
             if (!input.tapInternalKey) {
                 input.tapInternalKey = toXOnly(MultiSignTransaction.numsPoint);
             }
@@ -210,17 +216,17 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
                 input.tapLeafScript = [
                     {
                         leafVersion: 192,
-                        script: decoded[decoded.length - 2],
-                        controlBlock: decoded[decoded.length - 1],
+                        script: decoded[decoded.length - 2] as Uint8Array,
+                        controlBlock: decoded[decoded.length - 1] as Uint8Array,
                     },
                 ];
 
                 // we must insert all the partial signatures, decoded.length - 2
                 for (let j = 0; j < decoded.length - 2; j += 3) {
                     partialSignatures.push({
-                        signature: decoded[j],
-                        leafHash: decoded[j + 1],
-                        pubkey: decoded[j + 2],
+                        signature: decoded[j] as Uint8Array,
+                        leafHash: decoded[j + 1] as Uint8Array,
+                        pubkey: decoded[j + 2] as Uint8Array,
                     });
                 }
 
@@ -266,14 +272,14 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
     public static partialFinalizer = (
         inputIndex: number,
         input: PsbtInput,
-        partialSignatures: Buffer[],
-        orderedPubKeys: Buffer[],
+        partialSignatures: Uint8Array[],
+        orderedPubKeys: Uint8Array[],
         isFinal: boolean,
     ) => {
         if (
             !input.tapLeafScript ||
-            !input.tapLeafScript[0].script ||
-            !input.tapLeafScript[0].controlBlock
+            !input.tapLeafScript[0]?.script ||
+            !input.tapLeafScript[0]?.controlBlock
         ) {
             throw new Error('Tap leaf script is required');
         }
@@ -282,7 +288,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
             throw new Error(`No new signatures for input ${inputIndex}.`);
         }
 
-        let scriptSolution: Buffer[] = [];
+        let scriptSolution: Uint8Array[] = [];
         if (!isFinal) {
             scriptSolution = input.tapScriptSig
                 .map((sig) => {
@@ -294,14 +300,14 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
             for (const pubKey of orderedPubKeys) {
                 let found = false;
                 for (const sig of input.tapScriptSig) {
-                    if (sig.pubkey.equals(toXOnly(pubKey))) {
+                    if (equals(sig.pubkey, toXOnly(pubKey as PublicKey))) {
                         scriptSolution.push(sig.signature);
                         found = true;
                     }
                 }
 
                 if (!found) {
-                    scriptSolution.push(Buffer.alloc(0));
+                    scriptSolution.push(new Uint8Array(0));
                 }
             }
 
@@ -312,9 +318,10 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
             scriptSolution = scriptSolution.concat(partialSignatures);
         }
 
+        const tapLeaf = input.tapLeafScript[0] as { script: Uint8Array; controlBlock: Uint8Array };
         const witness = scriptSolution
-            .concat(input.tapLeafScript[0].script)
-            .concat(input.tapLeafScript[0].controlBlock);
+            .concat(tapLeaf.script)
+            .concat(tapLeaf.controlBlock);
 
         return {
             finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witness),
@@ -333,12 +340,12 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
     ): TapScriptSig[] {
         const signatures = new Map<string, TapScriptSig>();
         for (const sig of original) {
-            signatures.set(sig.pubkey.toString('hex'), sig);
+            signatures.set(toHex(sig.pubkey), sig);
         }
 
         for (const sig of partial) {
-            if (!signatures.has(sig.pubkey.toString('hex'))) {
-                signatures.set(sig.pubkey.toString('hex'), sig);
+            if (!signatures.has(toHex(sig.pubkey))) {
+                signatures.set(toHex(sig.pubkey), sig);
             }
         }
 
@@ -356,13 +363,13 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
     public static attemptFinalizeInputs(
         psbt: Psbt,
         startIndex: number,
-        orderedPubKeys: Buffer[][],
+        orderedPubKeys: Uint8Array[][],
         isFinal: boolean,
     ): boolean {
         let finalizedInputs = 0;
         for (let i = startIndex; i < psbt.data.inputs.length; i++) {
             try {
-                const input = psbt.data.inputs[i];
+                const input = psbt.data.inputs[i] as PsbtInput;
 
                 if (!input.tapInternalKey) {
                     input.tapInternalKey = toXOnly(MultiSignTransaction.numsPoint);
@@ -377,17 +384,17 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
                     // we must insert all the partial signatures, decoded.length - 2
                     for (let j = 0; j < decoded.length - 2; j += 3) {
                         partialSignatures.push({
-                            signature: decoded[j],
-                            leafHash: decoded[j + 1],
-                            pubkey: decoded[j + 2],
+                            signature: decoded[j] as Uint8Array,
+                            leafHash: decoded[j + 1] as Uint8Array,
+                            pubkey: decoded[j + 2] as Uint8Array,
                         });
                     }
 
                     input.tapLeafScript = [
                         {
                             leafVersion: 192,
-                            script: decoded[decoded.length - 2],
-                            controlBlock: decoded[decoded.length - 1],
+                            script: decoded[decoded.length - 2] as Uint8Array,
+                            controlBlock: decoded[decoded.length - 1] as Uint8Array,
                         },
                     ];
 
@@ -405,13 +412,13 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
                         inputIndex: number,
                         input: PsbtInput,
                     ): {
-                        finalScriptWitness: Buffer | undefined;
+                        finalScriptWitness: Uint8Array | undefined;
                     } => {
                         return MultiSignTransaction.partialFinalizer(
                             inputIndex,
                             input,
                             [],
-                            orderedPubKeys[i - startIndex],
+                            orderedPubKeys[i - startIndex] as Uint8Array[],
                             isFinal,
                         );
                     },
@@ -448,7 +455,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
      * @returns {Promise<Psbt>} - The signed transaction in hex format
      * @throws {Error} - If something went wrong
      */
-    public async signPSBT(): Promise<Psbt> {
+    public override async signPSBT(): Promise<Psbt> {
         if (await this.signTransaction()) {
             return this.transaction;
         }
@@ -494,12 +501,12 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
 
         this.addOutput({
             address: this.refundVault,
-            value: Number(outputLeftAmount),
+            value: toSatoshi(outputLeftAmount),
         });
 
         this.addOutput({
             address: this.receiver,
-            value: Number(this.requestedAmount),
+            value: toSatoshi(this.requestedAmount),
         });
     }
 
@@ -522,7 +529,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
         transaction.addInputs(inputs, checkPartialSigs);
 
         for (let i = 0; i < this.updateInputs.length; i++) {
-            transaction.updateInput(i, this.updateInputs[i]);
+            transaction.updateInput(i, this.updateInputs[i] as UpdateInput);
         }
 
         transaction.addOutputs(outputs);
@@ -583,7 +590,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
      *
      * @returns {Buffer[]} The script solution
      */
-    protected getScriptSolution(input: PsbtInput): Buffer[] {
+    protected getScriptSolution(input: PsbtInput): Uint8Array[] {
         if (!input.tapScriptSig) {
             return [];
         }
@@ -667,7 +674,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
     private generateRedeemScripts(): void {
         this.targetScriptRedeem = {
             name: PaymentType.P2TR,
-            output: this.compiledTargetScript,
+            output: this.compiledTargetScript as Script,
             redeemVersion: 192,
         };
 

package/src/transaction/builders/SharedInteractionTransaction.ts

@@ -1,16 +1,28 @@
-import { P2TRPayment, PaymentType, Psbt, PsbtInput, Signer, Taptree, toXOnly, } from '@btc-vision/bitcoin';
-import { ECPairInterface } from 'ecpair';
+import {
+    type FinalScriptsFunc,
+    type P2TRPayment,
+    PaymentType,
+    Psbt,
+    type PsbtInput,
+    type Script,
+    type Signer,
+    type TapScriptSig,
+    type Taptree,
+    toXOnly,
+} from '@btc-vision/bitcoin';
+import { type UniversalSigner } from '@btc-vision/ecpair';
+import { isUniversalSigner } from '../../signer/TweakedSigner.js';
 import { MINIMUM_AMOUNT_REWARD, TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
-import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
+import type { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
 import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 import { TimeLockGenerator } from '../mineable/TimelockGenerator.js';
-import { IChallengeSolution } from '../../epoch/interfaces/IChallengeSolution.js';
-import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
+import type { IChallengeSolution } from '../../epoch/interfaces/IChallengeSolution.js';
+import type { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 
 /**
  * Shared interaction transaction
@@ -25,12 +37,12 @@ export abstract class SharedInteractionTransaction<
      * Random salt for the interaction
      * @type {Buffer}
      */
-    public readonly randomBytes: Buffer;
+    public readonly randomBytes: Uint8Array;
 
     protected targetScriptRedeem: P2TRPayment | null = null;
     protected leftOverFundsScriptRedeem: P2TRPayment | null = null;
 
-    protected abstract readonly compiledTargetScript: Buffer;
+    protected abstract readonly compiledTargetScript: Uint8Array;
     protected abstract readonly scriptTree: Taptree;
 
     protected readonly challenge: IChallengeSolution;
@@ -42,19 +54,19 @@ export abstract class SharedInteractionTransaction<
      * Calldata for the interaction
      * @protected
      */
-    protected readonly calldata: Buffer;
+    protected readonly calldata: Uint8Array;
 
     /**
      * Contract secret for the interaction
      * @protected
      */
-    protected abstract readonly contractSecret: Buffer;
+    protected abstract readonly contractSecret: Uint8Array;
 
     /**
      * Script signer for the interaction
      * @protected
      */
-    protected readonly scriptSigner: Signer | ECPairInterface;
+    protected readonly scriptSigner: Signer | UniversalSigner;
 
     /**
      * Disable auto refund
@@ -89,13 +101,13 @@ export abstract class SharedInteractionTransaction<
         this.scriptSigner = this.generateKeyPairFromSeed();
 
         this.calldataGenerator = new CalldataGenerator(
-            Buffer.from(this.signer.publicKey),
+            this.signer.publicKey,
             this.scriptSignerXOnlyPubKey(),
             this.network,
         );
     }
 
-    public exportCompiledTargetScript(): Buffer {
+    public exportCompiledTargetScript(): Uint8Array {
         return this.compiledTargetScript;
     }
 
@@ -103,7 +115,7 @@ export abstract class SharedInteractionTransaction<
      * Get the contract secret
      * @returns {Buffer} The contract secret
      */
-    public getContractSecret(): Buffer {
+    public getContractSecret(): Uint8Array {
         return this.contractSecret;
     }
 
@@ -111,7 +123,7 @@ export abstract class SharedInteractionTransaction<
      * Get the random bytes used for the interaction
      * @returns {Buffer} The random bytes
      */
-    public getRndBytes(): Buffer {
+    public getRndBytes(): Uint8Array {
         return this.randomBytes;
     }
 
@@ -127,17 +139,17 @@ export abstract class SharedInteractionTransaction<
      * @protected
      * @returns {Buffer} The internal pubkey as an x-only key
      */
-    protected scriptSignerXOnlyPubKey(): Buffer {
-        return toXOnly(Buffer.from(this.scriptSigner.publicKey));
+    protected scriptSignerXOnlyPubKey(): Uint8Array {
+        return toXOnly(this.scriptSigner.publicKey);
     }
 
     /**
      * Generate a key pair from the seed
      * @protected
      *
-     * @returns {ECPairInterface} The key pair
+     * @returns {UniversalSigner} The key pair
      */
-    protected generateKeyPairFromSeed(): ECPairInterface {
+    protected generateKeyPairFromSeed(): UniversalSigner {
         return EcKeyPair.fromSeedKeyPair(this.randomBytes, this.network);
     }
 
@@ -237,16 +249,16 @@ export abstract class SharedInteractionTransaction<
      *
      * @returns {Buffer[]} The script solution
      */
-    protected getScriptSolution(input: PsbtInput): Buffer[] {
+    protected getScriptSolution(input: PsbtInput): Uint8Array[] {
         if (!input.tapScriptSig) {
             throw new Error('Tap script signature is required');
         }
 
         return [
             this.contractSecret,
-            input.tapScriptSig[0].signature,
-            input.tapScriptSig[1].signature,
-        ] as Buffer[];
+            (input.tapScriptSig[0] as TapScriptSig).signature,
+            (input.tapScriptSig[1] as TapScriptSig).signature,
+        ] as Uint8Array[];
     }
 
     /**
@@ -303,7 +315,7 @@ export abstract class SharedInteractionTransaction<
         const signer: UnisatSigner = this.signer as UnisatSigner;
 
         // first, we sign the first input with the script signer.
-        await this.signInput(transaction, transaction.data.inputs[0], 0, this.scriptSigner);
+        await this.signInput(transaction, transaction.data.inputs[0] as PsbtInput, 0, this.scriptSigner);
 
         // then, we sign all the remaining inputs with the wallet signer.
         await signer.multiSignPsbt([transaction]);
@@ -323,28 +335,56 @@ export abstract class SharedInteractionTransaction<
     }
 
     protected override async signInputsNonWalletBased(transaction: Psbt): Promise<void> {
-        for (let i = 0; i < transaction.data.inputs.length; i++) {
-            if (i === 0) {
-                await this.signInput(transaction, transaction.data.inputs[i], i, this.scriptSigner);
-
-                await this.signInput(
-                    transaction,
-                    transaction.data.inputs[i],
-                    i,
-                    this.getSignerKey(),
+        // Input 0: always sequential (needs scriptSigner + main signer, custom finalizer)
+        await this.signInput(transaction, transaction.data.inputs[0] as PsbtInput, 0, this.scriptSigner);
+        await this.signInput(transaction, transaction.data.inputs[0] as PsbtInput, 0, this.getSignerKey());
+        transaction.finalizeInput(0, this.customFinalizer.bind(this));
+
+        // Inputs 1+: parallel key-path if available, then sequential for remaining
+        if (this.canUseParallelSigning && isUniversalSigner(this.signer)) {
+            let parallelSignedIndices = new Set<number>();
+
+            try {
+                const result = await this.signKeyPathInputsParallel(transaction, new Set([0]));
+                if (result.success) {
+                    parallelSignedIndices = new Set(result.signatures.keys());
+                }
+            } catch (e) {
+                this.error(
+                    `Parallel signing failed, falling back to sequential: ${(e as Error).message}`,
                 );
+            }
 
-                transaction.finalizeInput(0, this.customFinalizer.bind(this));
-            } else {
-                await this.signInput(transaction, transaction.data.inputs[i], i, this.signer);
-
-                try {
-                    transaction.finalizeInput(i, this.customFinalizerP2SH.bind(this));
-                } catch (e) {
-                    transaction.finalizeInput(i);
+            // Sign remaining inputs 1+ that weren't handled by parallel signing
+            for (let i = 1; i < transaction.data.inputs.length; i++) {
+                if (!parallelSignedIndices.has(i)) {
+                    await this.signInput(
+                        transaction,
+                        transaction.data.inputs[i] as PsbtInput,
+                        i,
+                        this.signer,
+                    );
                 }
             }
+        } else {
+            for (let i = 1; i < transaction.data.inputs.length; i++) {
+                await this.signInput(transaction, transaction.data.inputs[i] as PsbtInput, i, this.signer);
+            }
         }
+
+        // Finalize inputs 1+
+        for (let i = 1; i < transaction.data.inputs.length; i++) {
+            try {
+                transaction.finalizeInput(
+                    i,
+                    this.customFinalizerP2SH.bind(this) as FinalScriptsFunc,
+                );
+            } catch {
+                transaction.finalizeInput(i);
+            }
+        }
+
+        this.finalized = true;
     }
 
     protected async createMineableRewardOutputs(): Promise<void> {
@@ -367,22 +407,6 @@ export abstract class SharedInteractionTransaction<
         }
     }
 
-    /**
-     * Get the public keys
-     * @private
-     *
-     * @returns {Buffer[]} The public keys
-     */
-    private getPubKeys(): Buffer[] {
-        const pubKeys = [Buffer.from(this.signer.publicKey)];
-
-        if (this.scriptSigner) {
-            pubKeys.push(Buffer.from(this.scriptSigner.publicKey));
-        }
-
-        return pubKeys;
-    }
-
     /**
      * Generate the redeem scripts
      * @private
@@ -396,7 +420,7 @@ export abstract class SharedInteractionTransaction<
     private generateRedeemScripts(): void {
         this.targetScriptRedeem = {
             name: PaymentType.P2TR,
-            output: this.compiledTargetScript,
+            output: this.compiledTargetScript as Script,
             redeemVersion: 192,
         };