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

package/src/transaction/interfaces/ICancelTransactionParameters.ts

@@ -1,8 +1,8 @@
-import { ITransactionParameters } from './ITransactionParameters.js';
+import type { ITransactionParameters } from './ITransactionParameters.js';
 
 export interface ICancelTransactionParameters extends Omit<
     ITransactionParameters,
     'priorityFee' | 'gasSatFee'
 > {
-    readonly compiledTargetScript: string | Buffer;
+    readonly compiledTargetScript: string | Uint8Array;
 }

package/src/transaction/interfaces/IConsolidatedTransactionParameters.ts

@@ -1,5 +1,5 @@
-import { IInteractionParameters } from './ITransactionParameters.js';
-import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
+import type { IInteractionParameters } from './ITransactionParameters.js';
+import type { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 
 /**
  * Extended P2WSH address with hash commitments for CHCT system.
@@ -13,13 +13,13 @@ import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
  */
 export interface IHashCommittedP2WSH extends IP2WSHAddress {
     /** The HASH160 values of all data chunks this output commits to (in order) */
-    readonly dataHashes: Buffer[];
+    readonly dataHashes: Uint8Array[];
     /** The actual data chunks (stored for later reveal, in order) */
-    readonly dataChunks: Buffer[];
+    readonly dataChunks: Uint8Array[];
     /** The starting index of this output's chunks in the overall data sequence */
     readonly chunkStartIndex: number;
     /** The P2WSH scriptPubKey (OP_0 <32-byte-hash>) */
-    readonly scriptPubKey: Buffer;
+    readonly scriptPubKey: Uint8Array;
 }
 
 /**

package/src/transaction/interfaces/ICustomTransactionParameters.ts

@@ -1,15 +1,15 @@
-import { Stack } from '@btc-vision/bitcoin';
-import { SharedInteractionParameters } from './ITransactionParameters.js';
+import type { Stack } from '@btc-vision/bitcoin';
+import type { SharedInteractionParameters } from './ITransactionParameters.js';
 
 export interface ICustomTransactionParameters extends Omit<
     SharedInteractionParameters,
     'challenge'
 > {
-    script: (Buffer | Stack)[];
-    witnesses: Buffer[];
+    script: (Uint8Array | Stack)[];
+    witnesses: Uint8Array[];
 
     /** optional Taproot annex payload (without the 0x50 prefix) */
-    annex?: Buffer;
+    annex?: Uint8Array;
 
     to: string;
 }

package/src/transaction/interfaces/ITransactionParameters.ts

@@ -1,9 +1,9 @@
-import { UTXO } from '../../utxo/interfaces/IUTXO.js';
-import { ITweakedTransactionData } from './ITweakedTransactionData.js';
-import { ChainId } from '../../network/ChainId.js';
-import { PsbtOutputExtended } from '@btc-vision/bitcoin';
-import { IChallengeSolution } from '../../epoch/interfaces/IChallengeSolution.js';
-import { AddressRotationConfigBase } from '../../signer/IRotationSigner.js';
+import type { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import type { ITweakedTransactionData } from './ITweakedTransactionData.js';
+import type { ChainId } from '../../network/ChainId.js';
+import type { PsbtOutputExtended } from '@btc-vision/bitcoin';
+import type { IChallengeSolution } from '../../epoch/interfaces/IChallengeSolution.js';
+import type { AddressRotationConfigBase } from '../../signer/IRotationSigner.js';
 
 export interface LoadedStorage {
     [key: string]: string[];
@@ -26,7 +26,7 @@ export interface ITransactionParameters extends ITweakedTransactionData {
 
     utxos: UTXO[];
 
-    nonWitnessUtxo?: Buffer;
+    nonWitnessUtxo?: Uint8Array;
     estimatedFees?: bigint;
 
     optionalInputs?: UTXO[];
@@ -35,14 +35,14 @@ export interface ITransactionParameters extends ITweakedTransactionData {
     chainId?: ChainId;
     noSignatures?: boolean;
 
-    readonly note?: string | Buffer;
+    readonly note?: string | Uint8Array;
     readonly anchor?: boolean;
 
     readonly feeRate: number;
     readonly priorityFee: bigint;
     readonly gasSatFee: bigint;
 
-    readonly compiledTargetScript?: Buffer | string;
+    readonly compiledTargetScript?: Uint8Array | string;
 
     /**
      * Address rotation configuration.
@@ -56,30 +56,43 @@ export interface IFundingTransactionParameters extends ITransactionParameters {
     amount: bigint;
 
     splitInputsInto?: number;
+
+    /**
+     * When true, fees are deducted from the output amount automatically.
+     * Useful for consolidation / send-max use cases where amount equals total UTXO value.
+     */
+    autoAdjustAmount?: boolean;
+
+    /**
+     * Extra UTXOs used exclusively to cover transaction fees.
+     * When provided, the output amount stays exact and fees are paid from these UTXOs.
+     * Any leftover becomes the change output as normal.
+     */
+    feeUtxos?: UTXO[];
 }
 
 export interface SharedInteractionParameters extends ITransactionParameters {
-    calldata?: Buffer;
+    calldata?: Uint8Array;
     disableAutoRefund?: boolean;
 
     readonly challenge: IChallengeSolution;
-    readonly randomBytes?: Buffer;
+    readonly randomBytes?: Uint8Array;
 
     readonly loadedStorage?: LoadedStorage;
     readonly isCancellation?: boolean;
 }
 
 export interface IInteractionParameters extends SharedInteractionParameters {
-    readonly calldata: Buffer;
+    readonly calldata: Uint8Array;
 
     readonly to: string;
     readonly contract?: string;
 }
 
 export interface IDeploymentParameters extends Omit<ITransactionParameters, 'to'> {
-    readonly bytecode: Buffer;
-    readonly calldata?: Buffer;
+    readonly bytecode: Uint8Array;
+    readonly calldata?: Uint8Array;
 
-    readonly randomBytes?: Buffer;
+    readonly randomBytes?: Uint8Array;
     readonly challenge: IChallengeSolution;
 }

package/src/transaction/interfaces/ITransactionResponses.ts

@@ -1,5 +1,5 @@
-import { RawChallenge } from '../../epoch/interfaces/IChallengeSolution.js';
-import { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import type { RawChallenge } from '../../epoch/interfaces/IChallengeSolution.js';
+import type { UTXO } from '../../utxo/interfaces/IUTXO.js';
 
 export interface DeploymentResult {
     readonly transaction: [string, string];

package/src/transaction/interfaces/ITweakedTransactionData.ts

@@ -1,19 +1,20 @@
-import { Network, Signer } from '@btc-vision/bitcoin';
-import { ECPairInterface } from 'ecpair';
-import { QuantumBIP32Interface } from '@btc-vision/bip32';
-import { ChainId } from '../../network/ChainId.js';
-import { AddressRotationConfigBase } from '../../signer/IRotationSigner.js';
+import type { Network, Signer } from '@btc-vision/bitcoin';
+import type { SigningPoolLike, WorkerPoolConfig } from '@btc-vision/bitcoin';
+import type { UniversalSigner } from '@btc-vision/ecpair';
+import type { QuantumBIP32Interface } from '@btc-vision/bip32';
+import type { ChainId } from '../../network/ChainId.js';
+import type { AddressRotationConfigBase } from '../../signer/IRotationSigner.js';
 
 export type SupportedTransactionVersion = 1 | 2 | 3;
 
 export interface ITweakedTransactionData {
     readonly mldsaSigner: QuantumBIP32Interface | null;
-    readonly signer: Signer | ECPairInterface;
+    readonly signer: Signer | UniversalSigner;
     readonly network: Network;
     readonly chainId?: ChainId;
-    readonly nonWitnessUtxo?: Buffer;
+    readonly nonWitnessUtxo?: Uint8Array;
     readonly noSignatures?: boolean;
-    readonly unlockScript?: Buffer[];
+    readonly unlockScript?: Uint8Array[];
     readonly txVersion?: SupportedTransactionVersion;
 
     /**
@@ -21,4 +22,12 @@ export interface ITweakedTransactionData {
      * When enabled, each UTXO can be signed by a different signer.
      */
     readonly addressRotation?: AddressRotationConfigBase;
+
+    /**
+     * Parallel signing configuration using worker threads.
+     * Pass a WorkerSigningPool instance (recommended for reuse) or a WorkerPoolConfig.
+     * When provided, key-path taproot inputs are signed in parallel.
+     * Falls back to sequential for address rotation, browser, or non-taproot inputs.
+     */
+    readonly parallelSigning?: SigningPoolLike | WorkerPoolConfig;
 }

package/src/transaction/interfaces/IWeb3ProviderTypes.ts

@@ -1,6 +1,6 @@
-import { IDeploymentParameters, IInteractionParameters } from './ITransactionParameters.js';
-import { ICustomTransactionParameters } from './ICustomTransactionParameters.js';
-import { ICancelTransactionParameters } from './ICancelTransactionParameters.js';
+import type { IDeploymentParameters, IInteractionParameters } from './ITransactionParameters.js';
+import type { ICustomTransactionParameters } from './ICustomTransactionParameters.js';
+import type { ICancelTransactionParameters } from './ICancelTransactionParameters.js';
 import { MLDSASecurityLevel } from '@btc-vision/bip32';
 
 export type InteractionParametersWithoutSigner = Omit<

package/src/transaction/interfaces/Tap.ts

@@ -1,4 +1,4 @@
-import {
+import type {
     PsbtInput as _PsbtInput,
     PsbtInputUpdate as _PsbtInputUpdate,
     PsbtOutput as _PsbtOutput,
@@ -14,8 +14,8 @@ import {
 
 export interface TapLeafScript {
     readonly leafVersion: number;
-    readonly controlBlock: Buffer;
-    readonly script: Buffer;
+    readonly controlBlock: Uint8Array;
+    readonly script: Uint8Array;
 }
 
 export interface UpdateInput {

package/src/transaction/mineable/IP2WSHAddress.ts

@@ -1,4 +1,4 @@
 export interface IP2WSHAddress {
     address: string;
-    witnessScript: Buffer;
+    witnessScript: Uint8Array;
 }

package/src/transaction/mineable/TimelockGenerator.ts

@@ -1,10 +1,18 @@
-import bitcoin, { Network, networks, opcodes, script } from '@btc-vision/bitcoin';
-import { IP2WSHAddress } from './IP2WSHAddress.js';
+import bitcoin, {
+    fromHex,
+    type Network,
+    networks,
+    opcodes,
+    type PublicKey,
+    type Script,
+    script,
+    type XOnlyPublicKey,
+} from '@btc-vision/bitcoin';
+import type { IP2WSHAddress } from './IP2WSHAddress.js';
 
 export class TimeLockGenerator {
-    private static readonly UNSPENDABLE_INTERNAL_KEY = Buffer.from(
+    private static readonly UNSPENDABLE_INTERNAL_KEY = fromHex(
         '50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0',
-        'hex',
     );
 
     private static readonly CSV_BLOCKS = 75;
@@ -14,11 +22,11 @@ export class TimeLockGenerator {
      * Note: This uses ECDSA, not Schnorr (Schnorr only available in Taproot)
      */
     public static generateTimeLockAddress(
-        publicKey: Buffer,
+        publicKey: PublicKey,
         network: Network = networks.bitcoin,
         csvBlocks: number = TimeLockGenerator.CSV_BLOCKS,
     ): IP2WSHAddress {
-        const witnessScript = this.generateTimeLockScript(publicKey, csvBlocks);
+        const witnessScript: Script = this.generateTimeLockScript(publicKey, csvBlocks);
 
         const p2wsh = bitcoin.payments.p2wsh({
             redeem: { output: witnessScript },
@@ -40,7 +48,7 @@ export class TimeLockGenerator {
      * Note: This uses Schnorr signatures
      */
     public static generateTimeLockAddressP2TR(
-        publicKey: Buffer,
+        publicKey: XOnlyPublicKey,
         network: Network = networks.bitcoin,
         csvBlocks: number = TimeLockGenerator.CSV_BLOCKS,
     ): string {
@@ -48,12 +56,11 @@ export class TimeLockGenerator {
             throw new Error('Public key must be 32 bytes for Taproot');
         }
 
-        const witnessScript = this.generateTimeLockScript(publicKey, csvBlocks);
-
+        const witnessScript: Script = this.generateTimeLockScript(publicKey, csvBlocks);
         const taproot = bitcoin.payments.p2tr({
             redeem: { output: witnessScript },
             network,
-            internalPubkey: TimeLockGenerator.UNSPENDABLE_INTERNAL_KEY,
+            internalPubkey: TimeLockGenerator.UNSPENDABLE_INTERNAL_KEY as XOnlyPublicKey,
         });
 
         if (!taproot.address) {
@@ -64,9 +71,9 @@ export class TimeLockGenerator {
     }
 
     private static generateTimeLockScript(
-        publicKey: Buffer,
+        publicKey: PublicKey | XOnlyPublicKey,
         csvBlocks: number = TimeLockGenerator.CSV_BLOCKS,
-    ): Buffer {
+    ): Script {
         return script.compile([
             script.number.encode(csvBlocks),
             opcodes.OP_CHECKSEQUENCEVERIFY,

package/src/transaction/offline/OfflineTransactionManager.ts

@@ -1,14 +1,14 @@
-import { Psbt, Signer } from '@btc-vision/bitcoin';
-import { ECPairInterface } from 'ecpair';
+import { fromHex, Psbt, type PsbtInput, type Signer, toHex } from '@btc-vision/bitcoin';
+import { type UniversalSigner } from '@btc-vision/ecpair';
 import { TransactionType } from '../enums/TransactionType.js';
 import { TransactionBuilder } from '../builders/TransactionBuilder.js';
 import { MultiSignTransaction } from '../builders/MultiSignTransaction.js';
-import { ISerializableTransactionState, PrecomputedData } from './interfaces/ISerializableState.js';
+import type { ISerializableTransactionState, PrecomputedData } from './interfaces/ISerializableState.js';
 import { TransactionSerializer } from './TransactionSerializer.js';
-import { ReconstructionOptions, TransactionReconstructor } from './TransactionReconstructor.js';
+import { type ReconstructionOptions, TransactionReconstructor } from './TransactionReconstructor.js';
 import { TransactionStateCapture } from './TransactionStateCapture.js';
 import { isMultiSigSpecificData } from './interfaces/ITypeSpecificData.js';
-import {
+import type {
     IDeploymentParameters,
     IFundingTransactionParameters,
     IInteractionParameters,
@@ -107,7 +107,7 @@ export class OfflineTransactionManager {
      */
     public static exportMultiSig(
         params: ITransactionParameters & {
-            pubkeys: Buffer[];
+            pubkeys: Uint8Array[];
             minimumSignatures: number;
             receiver: string;
             requestedAmount: bigint;
@@ -129,9 +129,9 @@ export class OfflineTransactionManager {
      */
     public static exportCustomScript(
         params: ITransactionParameters & {
-            scriptElements: (Buffer | number)[];
-            witnesses: Buffer[];
-            annex?: Buffer;
+            scriptElements: (Uint8Array | number)[];
+            witnesses: Uint8Array[];
+            annex?: Uint8Array;
         },
         precomputed?: Partial<PrecomputedData>,
     ): string {
@@ -147,7 +147,7 @@ export class OfflineTransactionManager {
      */
     public static exportCancel(
         params: ITransactionParameters & {
-            compiledTargetScript: Buffer | string;
+            compiledTargetScript: Uint8Array | string;
         },
         precomputed?: Partial<PrecomputedData>,
     ): string {
@@ -366,7 +366,7 @@ export class OfflineTransactionManager {
      */
     public static async multiSigAddSignature(
         serializedState: string,
-        signer: Signer | ECPairInterface,
+        signer: Signer | UniversalSigner,
     ): Promise<{
         state: string;
         signed: boolean;
@@ -380,7 +380,7 @@ export class OfflineTransactionManager {
         }
 
         const typeData = state.typeSpecificData;
-        const pubkeys = typeData.pubkeys.map((pk) => Buffer.from(pk, 'hex'));
+        const pubkeys = typeData.pubkeys.map((pk) => fromHex(pk));
 
         // Parse existing PSBT or create new one
         let psbt: Psbt;
@@ -411,7 +411,7 @@ export class OfflineTransactionManager {
         );
 
         // Finalize inputs (partial finalization to preserve signatures)
-        const orderedPubKeys: Buffer[][] = [];
+        const orderedPubKeys: Uint8Array[][] = [];
         for (let i = typeData.originalInputCount; i < psbt.data.inputs.length; i++) {
             orderedPubKeys.push(pubkeys);
         }
@@ -451,7 +451,7 @@ export class OfflineTransactionManager {
      */
     public static multiSigHasSigned(
         serializedState: string,
-        signerPubKey: Buffer | string,
+        signerPubKey: Uint8Array | string,
     ): boolean {
         const state = TransactionSerializer.fromBase64(serializedState);
 
@@ -468,9 +468,8 @@ export class OfflineTransactionManager {
         const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
         const psbt = Psbt.fromBase64(typeData.existingPsbtBase64, { network });
 
-        const pubKeyBuffer = Buffer.isBuffer(signerPubKey)
-            ? signerPubKey
-            : Buffer.from(signerPubKey, 'hex');
+        const pubKeyBuffer =
+            signerPubKey instanceof Uint8Array ? signerPubKey : fromHex(signerPubKey);
 
         return MultiSignTransaction.verifyIfSigned(psbt, pubKeyBuffer);
     }
@@ -512,11 +511,11 @@ export class OfflineTransactionManager {
         const signerSet = new Set<string>();
 
         for (let i = typeData.originalInputCount; i < psbt.data.inputs.length; i++) {
-            const input = psbt.data.inputs[i];
+            const input = psbt.data.inputs[i] as PsbtInput;
 
             if (input.tapScriptSig) {
                 for (const sig of input.tapScriptSig) {
-                    signerSet.add(sig.pubkey.toString('hex'));
+                    signerSet.add(toHex(sig.pubkey));
                 }
             }
 
@@ -526,8 +525,8 @@ export class OfflineTransactionManager {
                 );
 
                 for (let j = 0; j < decoded.length - 2; j += 3) {
-                    const pubKey = decoded[j + 2];
-                    signerSet.add(pubKey.toString('hex'));
+                    const pubKey = decoded[j + 2] as Uint8Array;
+                    signerSet.add(toHex(pubKey));
                 }
             }
         }
@@ -565,8 +564,8 @@ export class OfflineTransactionManager {
         const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
         const psbt = Psbt.fromBase64(typeData.existingPsbtBase64, { network });
 
-        const pubkeys = typeData.pubkeys.map((pk) => Buffer.from(pk, 'hex'));
-        const orderedPubKeys: Buffer[][] = [];
+        const pubkeys = typeData.pubkeys.map((pk) => fromHex(pk));
+        const orderedPubKeys: Uint8Array[][] = [];
 
         for (let i = typeData.originalInputCount; i < psbt.data.inputs.length; i++) {
             orderedPubKeys.push(pubkeys);