@btc-vision/transaction 1.8.0-beta.0 → 1.8.0-beta.10

package/src/transaction/builders/InteractionTransactionP2WDA.ts

@@ -1,18 +1,18 @@
-import { Buffer } from 'buffer';
-import { Psbt, PsbtInput, toXOnly } from '@btc-vision/bitcoin';
+import { concat, fromHex, Psbt, type PsbtInput, toXOnly } from '@btc-vision/bitcoin';
+import type { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { TransactionType } from '../enums/TransactionType.js';
-import { IInteractionParameters } from '../interfaces/ITransactionParameters.js';
+import type { IInteractionParameters } from '../interfaces/ITransactionParameters.js';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { MessageSigner } from '../../keypair/MessageSigner.js';
 import { Compressor } from '../../bytecode/Compressor.js';
 import { P2WDAGenerator } from '../../generators/builders/P2WDAGenerator.js';
-import { Feature, FeaturePriority, Features } from '../../generators/Features.js';
+import { type Feature, FeaturePriority, Features } from '../../generators/Features.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
-import { IChallengeSolution } from '../../epoch/interfaces/IChallengeSolution.js';
-import { ECPairInterface } from 'ecpair';
+import type { IChallengeSolution } from '../../epoch/interfaces/IChallengeSolution.js';
+import { type UniversalSigner } from '@btc-vision/ecpair';
 import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
-import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
+import type { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 import { TimeLockGenerator } from '../mineable/TimelockGenerator.js';
 
 /**
@@ -33,19 +33,18 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
      * @protected
      */
     protected readonly disableAutoRefund: boolean;
-    private readonly contractAddress: string;
-    private readonly contractSecret: Buffer;
-    private readonly calldata: Buffer;
+    private readonly contractSecret: Uint8Array;
+    private readonly calldata: Uint8Array;
     private readonly challenge: IChallengeSolution;
-    private readonly randomBytes: Buffer;
+    private readonly randomBytes: Uint8Array;
     private p2wdaGenerator: P2WDAGenerator;
-    private scriptSigner: ECPairInterface;
+    private scriptSigner: UniversalSigner;
     private p2wdaInputIndices: Set<number> = new Set();
     /**
      * The compiled operation data from CalldataGenerator
      * This is exactly what would go in a taproot script, but we put it in witness instead
      */
-    private readonly compiledOperationData: Buffer | null = null;
+    private readonly compiledOperationData: Uint8Array | null = null;
 
     public constructor(parameters: IInteractionParameters) {
         super(parameters);
@@ -67,8 +66,7 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
         }
 
         this.disableAutoRefund = parameters.disableAutoRefund || false;
-        this.contractAddress = parameters.to;
-        this.contractSecret = Buffer.from(parameters.contract.replace('0x', ''), 'hex');
+        this.contractSecret = fromHex(parameters.contract.replace('0x', ''));
         this.calldata = Compressor.compress(parameters.calldata);
         this.challenge = parameters.challenge;
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
@@ -79,7 +77,7 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
         // Create the P2WDA generator instead of CalldataGenerator
         // P2WDA needs a different data format optimized for witness embedding
         this.p2wdaGenerator = new P2WDAGenerator(
-            Buffer.from(this.signer.publicKey),
+            this.signer.publicKey,
             this.scriptSignerXOnlyPubKey(),
             this.network,
         );
@@ -98,10 +96,10 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
         this.validateP2WDAInputs();
 
         if (parameters.compiledTargetScript) {
-            if (Buffer.isBuffer(parameters.compiledTargetScript)) {
+            if (parameters.compiledTargetScript instanceof Uint8Array) {
                 this.compiledOperationData = parameters.compiledTargetScript;
             } else if (typeof parameters.compiledTargetScript === 'string') {
-                this.compiledOperationData = Buffer.from(parameters.compiledTargetScript, 'hex');
+                this.compiledOperationData = fromHex(parameters.compiledTargetScript);
             } else {
                 throw new Error('Invalid compiled target script format.');
             }
@@ -124,7 +122,7 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
     /**
      * Get random bytes (for compatibility if needed elsewhere)
      */
-    public getRndBytes(): Buffer {
+    public getRndBytes(): Uint8Array {
         return this.randomBytes;
     }
 
@@ -138,7 +136,7 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
     /**
      * Get contract secret (for compatibility if needed elsewhere)
      */
-    public getContractSecret(): Buffer {
+    public getContractSecret(): Uint8Array {
         return this.contractSecret;
     }
 
@@ -173,7 +171,7 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
     protected override async signInputs(transaction: Psbt): Promise<void> {
         // Sign all inputs
         for (let i = 0; i < transaction.data.inputs.length; i++) {
-            await this.signInput(transaction, transaction.data.inputs[i], i, this.signer);
+            await this.signInput(transaction, transaction.data.inputs[i] as PsbtInput, i, this.signer);
         }
 
         // Finalize with appropriate finalizers
@@ -221,35 +219,35 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
     /**
      * Generate keypair from seed (same as SharedInteractionTransaction)
      */
-    private generateKeyPairFromSeed(): ECPairInterface {
+    private generateKeyPairFromSeed(): UniversalSigner {
         return EcKeyPair.fromSeedKeyPair(this.randomBytes, this.network);
     }
 
     /**
      * Get script signer x-only pubkey (same as SharedInteractionTransaction)
      */
-    private scriptSignerXOnlyPubKey(): Buffer {
-        return toXOnly(Buffer.from(this.scriptSigner.publicKey));
+    private scriptSignerXOnlyPubKey(): Uint8Array {
+        return toXOnly(this.scriptSigner.publicKey);
     }
 
     /**
      * Validate that input 0 is P2WDA
      */
     private validateP2WDAInputs(): void {
-        if (this.utxos.length === 0 || !P2WDADetector.isP2WDAUTXO(this.utxos[0])) {
+        if (this.utxos.length === 0 || !P2WDADetector.isP2WDAUTXO(this.utxos[0] as UTXO)) {
             throw new Error('Input 0 must be a P2WDA UTXO');
         }
 
         // Track all P2WDA inputs
         for (let i = 0; i < this.utxos.length; i++) {
-            if (P2WDADetector.isP2WDAUTXO(this.utxos[i])) {
+            if (P2WDADetector.isP2WDAUTXO(this.utxos[i] as UTXO)) {
                 this.p2wdaInputIndices.add(i);
             }
         }
 
         for (let i = 0; i < this.optionalInputs.length; i++) {
             const actualIndex = this.utxos.length + i;
-            if (P2WDADetector.isP2WDAUTXO(this.optionalInputs[i])) {
+            if (P2WDADetector.isP2WDAUTXO(this.optionalInputs[i] as UTXO)) {
                 this.p2wdaInputIndices.add(actualIndex);
             }
         }
@@ -291,8 +289,8 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
         inputIndex: number,
         input: PsbtInput,
     ): {
-        finalScriptSig: Buffer | undefined;
-        finalScriptWitness: Buffer | undefined;
+        finalScriptSig: Uint8Array | undefined;
+        finalScriptWitness: Uint8Array | undefined;
     } {
         if (!input.partialSig || input.partialSig.length === 0) {
             throw new Error(`No signature for P2WDA input #${inputIndex}`);
@@ -306,17 +304,17 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
             throw new Error('Operation data not compiled');
         }
 
-        const txSignature = input.partialSig[0].signature;
-        const messageToSign = Buffer.concat([txSignature, this.compiledOperationData]);
+        const txSignature = (input.partialSig[0] as { signature: Uint8Array }).signature;
+        const messageToSign = concat([txSignature, this.compiledOperationData]);
         const signedMessage = MessageSigner.signMessage(
-            this.signer as ECPairInterface,
+            this.signer as UniversalSigner,
             messageToSign,
         );
 
-        const schnorrSignature = Buffer.from(signedMessage.signature);
+        const schnorrSignature = signedMessage.signature;
 
         // Combine and compress: COMPRESS(signature + compiledOperationData)
-        const fullData = Buffer.concat([schnorrSignature, this.compiledOperationData]);
+        const fullData = concat([schnorrSignature, this.compiledOperationData]);
         const compressedData = Compressor.compress(fullData);
 
         // Split into chunks
@@ -329,15 +327,15 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
         }
 
         // Build witness stack
-        const witnessStack: Buffer[] = [txSignature];
+        const witnessStack: Uint8Array[] = [txSignature];
 
         // Add exactly 10 data fields
         // Bitcoin stack is reversed!
         for (let i = 0; i < InteractionTransactionP2WDA.MAX_WITNESS_FIELDS; i++) {
-            witnessStack.push(i < chunks.length ? chunks[i] : Buffer.alloc(0));
+            witnessStack.push(i < chunks.length ? (chunks[i] as Uint8Array) : new Uint8Array(0));
         }
 
-        witnessStack.push(input.witnessScript);
+        witnessStack.push(input.witnessScript as Uint8Array);
 
         return {
             finalScriptSig: undefined,
@@ -348,8 +346,8 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
     /**
      * Split data into 80-byte chunks
      */
-    private splitIntoWitnessChunks(data: Buffer): Buffer[] {
-        const chunks: Buffer[] = [];
+    private splitIntoWitnessChunks(data: Uint8Array): Uint8Array[] {
+        const chunks: Uint8Array[] = [];
         let offset = 0;
 
         while (offset < data.length) {
@@ -357,7 +355,7 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
                 InteractionTransactionP2WDA.MAX_BYTES_PER_WITNESS,
                 data.length - offset,
             );
-            chunks.push(Buffer.from(data.subarray(offset, offset + size)));
+            chunks.push(data.slice(offset, offset + size));
             offset += size;
         }
 

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,
         };