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

package/src/transaction/builders/DeploymentTransaction.ts

@@ -1,17 +1,23 @@
 import { TransactionType } from '../enums/TransactionType.js';
-import { IDeploymentParameters } from '../interfaces/ITransactionParameters.js';
+import type { IDeploymentParameters } from '../interfaces/ITransactionParameters.js';
 import {
+    concat,
     crypto as bitCrypto,
-    P2TRPayment,
+    type FinalScriptsFunc,
+    fromHex,
+    type P2TRPayment,
     PaymentType,
     Psbt,
-    PsbtInput,
-    Signer,
-    Taptree,
+    type PsbtInput,
+    type Script,
+    type Signer,
+    type TapScriptSig,
+    type Taptree,
+    toHex,
     toXOnly,
 } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
-import { TapLeafScript } from '../interfaces/Tap.js';
+import type { TapLeafScript } from '../interfaces/Tap.js';
 import {
     DeploymentGenerator,
     versionBuffer,
@@ -20,13 +26,14 @@ import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
 import { Compressor } from '../../bytecode/Compressor.js';
 import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
-import { ECPairInterface } from 'ecpair';
+import { type UniversalSigner } from '@btc-vision/ecpair';
+import { isUniversalSigner } from '../../signer/TweakedSigner.js';
 import { Address } from '../../keypair/Address.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 import { TimeLockGenerator } from '../mineable/TimelockGenerator.js';
-import { IChallengeSolution } from '../../epoch/interfaces/IChallengeSolution.js';
-import { Feature, FeaturePriority, Features } from '../../generators/Features.js';
-import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
+import type { IChallengeSolution } from '../../epoch/interfaces/IChallengeSolution.js';
+import { type Feature, FeaturePriority, Features } from '../../generators/Features.js';
+import type { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 
 export class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     public static readonly MAXIMUM_CONTRACT_SIZE = 128 * 1024;
@@ -45,7 +52,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * The tap leaf script
      * @private
      */
-    protected tapLeafScript: TapLeafScript | null = null;
+    protected override tapLeafScript: TapLeafScript | null = null;
     private readonly deploymentVersion: number = 0x00;
     /**
      * The target script redeem
@@ -61,7 +68,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * The compiled target script
      * @private
      */
-    private readonly compiledTargetScript: Buffer;
+    private readonly compiledTargetScript: Uint8Array;
     /**
      * The script tree
      * @private
@@ -77,25 +84,25 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * The contract seed
      * @private
      */
-    private readonly contractSeed: Buffer;
+    private readonly contractSeed: Uint8Array;
 
     /**
      * The contract bytecode
      * @private
      */
-    private readonly bytecode: Buffer;
+    private readonly bytecode: Uint8Array;
 
     /**
      * Constructor calldata
      * @private
      */
-    private readonly calldata?: Buffer;
+    private readonly calldata?: Uint8Array;
 
     /**
      * The contract signer
      * @private
      */
-    private readonly contractSigner: Signer | ECPairInterface;
+    private readonly contractSigner: Signer | UniversalSigner;
 
     /**
      * The contract public key
@@ -107,7 +114,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * The contract salt random bytes
      * @private
      */
-    private readonly randomBytes: Buffer;
+    private readonly randomBytes: Uint8Array;
     private _computedAddress: string | undefined;
 
     public constructor(parameters: IDeploymentParameters) {
@@ -117,7 +124,9 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             throw new Error('MLDSA signer must be defined to deploy a contract.');
         }
 
-        this.bytecode = Compressor.compress(Buffer.concat([versionBuffer, parameters.bytecode]));
+        this.bytecode = Compressor.compress(
+            new Uint8Array([...versionBuffer, ...parameters.bytecode]),
+        );
 
         this.verifyBytecode();
 
@@ -141,16 +150,16 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         this.contractSigner = EcKeyPair.fromSeedKeyPair(this.contractSeed, this.network);
 
         this.deploymentGenerator = new DeploymentGenerator(
-            Buffer.from(this.signer.publicKey),
+            this.signer.publicKey,
             this.contractSignerXOnlyPubKey(),
             this.network,
         );
 
         if (parameters.compiledTargetScript) {
-            if (Buffer.isBuffer(parameters.compiledTargetScript)) {
+            if (parameters.compiledTargetScript instanceof Uint8Array) {
                 this.compiledTargetScript = parameters.compiledTargetScript;
             } else if (typeof parameters.compiledTargetScript === 'string') {
-                this.compiledTargetScript = Buffer.from(parameters.compiledTargetScript, 'hex');
+                this.compiledTargetScript = fromHex(parameters.compiledTargetScript);
             } else {
                 throw new Error('Invalid compiled target script format.');
             }
@@ -169,7 +178,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
 
         this.internalInit();
 
-        this._contractPubKey = '0x' + this.contractSeed.toString('hex');
+        this._contractPubKey = '0x' + toHex(this.contractSeed);
         this._contractAddress = new Address(this.contractSeed);
     }
 
@@ -194,7 +203,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         return this.to || this.getScriptAddress();
     }
 
-    public exportCompiledTargetScript(): Buffer {
+    public exportCompiledTargetScript(): Uint8Array {
         return this.compiledTargetScript;
     }
 
@@ -202,7 +211,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * Get the random bytes used for the interaction
      * @returns {Buffer} The random bytes
      */
-    public getRndBytes(): Buffer {
+    public getRndBytes(): Uint8Array {
         return this.randomBytes;
     }
 
@@ -232,8 +241,8 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * Get the contract signer public key
      * @protected
      */
-    protected contractSignerXOnlyPubKey(): Buffer {
-        return toXOnly(Buffer.from(this.contractSigner.publicKey));
+    protected contractSignerXOnlyPubKey(): Uint8Array {
+        return toXOnly(this.contractSigner.publicKey);
     }
 
     /**
@@ -279,7 +288,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         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.contractSigner);
+        await this.signInput(transaction, transaction.data.inputs[0] as PsbtInput, 0, this.contractSigner);
 
         // then, we sign all the remaining inputs with the wallet signer.
         await signer.multiSignPsbt([transaction]);
@@ -303,7 +312,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * @param {Psbt} transaction The transaction to sign
      * @protected
      */
-    protected async signInputs(transaction: Psbt): Promise<void> {
+    protected override async signInputs(transaction: Psbt): Promise<void> {
         if (!this.contractSigner) {
             await super.signInputs(transaction);
 
@@ -315,21 +324,45 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             return;
         }
 
-        for (let i = 0; i < transaction.data.inputs.length; i++) {
-            if (i === 0) {
-                // multi sig input
-                transaction.signInput(0, this.contractSigner);
-                transaction.signInput(0, this.getSignerKey());
+        // Input 0: sequential (contractSigner + main signer, custom finalizer)
+        transaction.signInput(0, this.contractSigner);
+        transaction.signInput(0, this.getSignerKey());
+        transaction.finalizeInput(0, this.customFinalizer.bind(this));
+
+        // Inputs 1+: parallel key-path if available, then sequential for remaining
+        const signedIndices = new Set<number>([0]);
+
+        if (this.canUseParallelSigning && isUniversalSigner(this.signer)) {
+            try {
+                const result = await this.signKeyPathInputsParallel(
+                    transaction,
+                    new Set([0]),
+                );
+                if (result.success) {
+                    for (const idx of result.signatures.keys()) signedIndices.add(idx);
+                }
+            } catch (e) {
+                this.error(
+                    `Parallel signing failed: ${(e as Error).message}`,
+                );
+            }
+        }
 
-                transaction.finalizeInput(0, this.customFinalizer.bind(this));
-            } else {
+        for (let i = 1; i < transaction.data.inputs.length; i++) {
+            if (!signedIndices.has(i)) {
                 transaction.signInput(i, this.getSignerKey());
+            }
+        }
 
-                try {
-                    transaction.finalizeInput(i, this.customFinalizerP2SH.bind(this));
-                } catch (e) {
-                    transaction.finalizeInput(i);
-                }
+        // 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);
             }
         }
     }
@@ -419,16 +452,16 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * Generate the contract seed for the deployment
      * @private
      */
-    private getContractSeed(): Buffer {
+    private getContractSeed(): Uint8Array {
         if (!this.bytecode) {
             throw new Error('Bytecode is required');
         }
 
         // Concatenate deployer pubkey, salt, and sha256(bytecode)
-        const deployerPubKey: Buffer = this.internalPubKeyToXOnly();
-        const salt: Buffer = bitCrypto.hash256(this.randomBytes);
-        const sha256OfBytecode: Buffer = bitCrypto.hash256(this.bytecode);
-        const buf: Buffer = Buffer.concat([deployerPubKey, salt, sha256OfBytecode]);
+        const deployerPubKey = this.internalPubKeyToXOnly();
+        const salt = bitCrypto.hash256(this.randomBytes);
+        const sha256OfBytecode = bitCrypto.hash256(this.bytecode);
+        const buf = concat([deployerPubKey, salt, sha256OfBytecode]);
 
         return bitCrypto.hash256(buf);
     }
@@ -449,8 +482,8 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
 
         const scriptSolution = [
             this.randomBytes,
-            input.tapScriptSig[0].signature,
-            input.tapScriptSig[1].signature,
+            (input.tapScriptSig[0] as TapScriptSig).signature,
+            (input.tapScriptSig[1] as TapScriptSig).signature,
         ];
 
         const witness = scriptSolution
@@ -462,20 +495,6 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         };
     };
 
-    /**
-     * Get the public keys for the redeem scripts
-     * @private
-     */
-    private getPubKeys(): Buffer[] {
-        const pubkeys = [Buffer.from(this.signer.publicKey)];
-
-        if (this.contractSigner) {
-            pubkeys.push(Buffer.from(this.contractSigner.publicKey));
-        }
-
-        return pubkeys;
-    }
-
     /**
      * Generate the redeem scripts
      * @private
@@ -484,7 +503,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         this.targetScriptRedeem = {
             name: PaymentType.P2TR,
             //pubkeys: this.getPubKeys(),
-            output: this.compiledTargetScript,
+            output: this.compiledTargetScript as Script,
             redeemVersion: 192,
         };
 
@@ -500,7 +519,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * Get the second leaf script
      * @private
      */
-    private getLeafScript(): Buffer {
+    private getLeafScript(): Script {
         return this.LOCK_LEAF_SCRIPT;
     }
 

package/src/transaction/builders/FundingTransaction.ts

@@ -1,8 +1,8 @@
 import { TransactionType } from '../enums/TransactionType.js';
-import { IFundingTransactionParameters } from '../interfaces/ITransactionParameters.js';
-import { opcodes, script, Signer } from '@btc-vision/bitcoin';
+import type { IFundingTransactionParameters } from '../interfaces/ITransactionParameters.js';
+import { fromHex, opcodes, type Script, script, type Signer, toSatoshi } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
-import { ECPairInterface } from 'ecpair';
+import { type UniversalSigner } from '@btc-vision/ecpair';
 
 export class FundingTransaction extends TransactionBuilder<TransactionType.FUNDING> {
     public readonly type: TransactionType.FUNDING = TransactionType.FUNDING;
@@ -30,18 +30,18 @@ export class FundingTransaction extends TransactionBuilder<TransactionType.FUNDI
         if (this.splitInputsInto > 1) {
             this.splitInputs(this.amount);
         } else if (this.isPubKeyDestination) {
-            const pubKeyScript = script.compile([
-                Buffer.from(this.to.replace('0x', ''), 'hex'),
+            const pubKeyScript: Script = script.compile([
+                fromHex(this.to.replace('0x', '')),
                 opcodes.OP_CHECKSIG,
             ]);
 
             this.addOutput({
-                value: Number(this.amount),
+                value: toSatoshi(this.amount),
                 script: pubKeyScript,
             });
         } else {
             this.addOutput({
-                value: Number(this.amount),
+                value: toSatoshi(this.amount),
                 address: this.to,
             });
         }
@@ -63,19 +63,19 @@ export class FundingTransaction extends TransactionBuilder<TransactionType.FUNDI
         for (let i = 0; i < this.splitInputsInto; i++) {
             if (this.isPubKeyDestination) {
                 this.addOutput({
-                    value: Number(splitAmount),
-                    script: Buffer.from(this.to.slice(2), 'hex'),
+                    value: toSatoshi(splitAmount),
+                    script: fromHex(this.to.slice(2)) as Script,
                 });
             } else {
                 this.addOutput({
-                    value: Number(splitAmount),
+                    value: toSatoshi(splitAmount),
                     address: this.to,
                 });
             }
         }
     }
 
-    protected override getSignerKey(): Signer | ECPairInterface {
+    protected override getSignerKey(): Signer | UniversalSigner {
         return this.signer;
     }
 }

package/src/transaction/builders/InteractionTransaction.ts

@@ -1,9 +1,9 @@
-import { Taptree } from '@btc-vision/bitcoin';
+import { fromHex, type Taptree } from '@btc-vision/bitcoin';
 import { TransactionType } from '../enums/TransactionType.js';
-import { TapLeafScript } from '../interfaces/Tap.js';
-import { IInteractionParameters } from '../interfaces/ITransactionParameters.js';
+import type { TapLeafScript } from '../interfaces/Tap.js';
+import type { IInteractionParameters } from '../interfaces/ITransactionParameters.js';
 import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
-import { Feature, FeaturePriority, Features } from '../../generators/Features.js';
+import { type Feature, FeaturePriority, Features } from '../../generators/Features.js';
 
 /**
  * Class for interaction transactions
@@ -12,16 +12,16 @@ import { Feature, FeaturePriority, Features } from '../../generators/Features.js
 export class InteractionTransaction extends SharedInteractionTransaction<TransactionType.INTERACTION> {
     public type: TransactionType.INTERACTION = TransactionType.INTERACTION;
 
-    protected readonly compiledTargetScript: Buffer;
+    protected readonly compiledTargetScript: Uint8Array;
     protected readonly scriptTree: Taptree;
 
-    protected tapLeafScript: TapLeafScript | null = null;
+    protected override tapLeafScript: TapLeafScript | null = null;
 
     /**
      * Contract secret for the interaction
      * @protected
      */
-    protected readonly contractSecret: Buffer;
+    protected readonly contractSecret: Uint8Array;
 
     public constructor(parameters: IInteractionParameters) {
         super(parameters);
@@ -30,17 +30,17 @@ export class InteractionTransaction extends SharedInteractionTransaction<Transac
             throw new Error('parameters.contract is required for interaction transaction.');
         }
 
-        this.contractSecret = Buffer.from(parameters.contract.replace('0x', ''), 'hex');
+        this.contractSecret = fromHex(parameters.contract.replace('0x', ''));
 
         if (this.contractSecret.length !== 32) {
             throw new Error('Invalid contract secret length. Expected 32 bytes.');
         }
 
         if (parameters.compiledTargetScript) {
-            if (Buffer.isBuffer(parameters.compiledTargetScript)) {
+            if (parameters.compiledTargetScript instanceof Uint8Array) {
                 this.compiledTargetScript = parameters.compiledTargetScript;
             } else if (typeof parameters.compiledTargetScript === 'string') {
-                this.compiledTargetScript = Buffer.from(parameters.compiledTargetScript, 'hex');
+                this.compiledTargetScript = fromHex(parameters.compiledTargetScript);
             } else {
                 throw new Error('Invalid compiled target script format.');
             }

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