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

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 { WorkerSigningPool, WorkerPoolConfig } from '@btc-vision/bitcoin/workers';
+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?: WorkerSigningPool | 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);

package/src/transaction/offline/TransactionReconstructor.ts

@@ -1,8 +1,17 @@
-import { Network, networks, PsbtOutputExtended, Signer, Stack } from '@btc-vision/bitcoin';
-import { ECPairInterface } from 'ecpair';
-import { QuantumBIP32Interface } from '@btc-vision/bip32';
-import { UTXO } from '../../utxo/interfaces/IUTXO.js';
-import { AddressRotationConfig, SignerMap } from '../../signer/AddressRotation.js';
+import {
+    fromHex,
+    type Network,
+    networks,
+    type PsbtOutputExtended,
+    type Script,
+    type Signer,
+    type Stack,
+    toSatoshi,
+} from '@btc-vision/bitcoin';
+import { type UniversalSigner } from '@btc-vision/ecpair';
+import type { QuantumBIP32Interface } from '@btc-vision/bip32';
+import type { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import type { AddressRotationConfig, SignerMap } from '../../signer/AddressRotation.js';
 import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { TransactionBuilder } from '../builders/TransactionBuilder.js';
@@ -12,35 +21,39 @@ import { InteractionTransaction } from '../builders/InteractionTransaction.js';
 import { MultiSignTransaction } from '../builders/MultiSignTransaction.js';
 import { CustomScriptTransaction } from '../builders/CustomScriptTransaction.js';
 import { CancelTransaction } from '../builders/CancelTransaction.js';
-import { ISerializableTransactionState, SerializedOutput, SerializedUTXO, } from './interfaces/ISerializableState.js';
+import type {
+    ISerializableTransactionState,
+    SerializedOutput,
+    SerializedUTXO,
+} from './interfaces/ISerializableState.js';
 import {
-    CancelSpecificData,
-    CustomScriptSpecificData,
-    DeploymentSpecificData,
-    FundingSpecificData,
-    InteractionSpecificData,
+    type CancelSpecificData,
+    type CustomScriptSpecificData,
+    type DeploymentSpecificData,
+    type FundingSpecificData,
+    type InteractionSpecificData,
     isCancelSpecificData,
     isCustomScriptSpecificData,
     isDeploymentSpecificData,
     isFundingSpecificData,
     isInteractionSpecificData,
     isMultiSigSpecificData,
-    MultiSigSpecificData,
+    type MultiSigSpecificData,
 } from './interfaces/ITypeSpecificData.js';
-import {
+import type {
     IDeploymentParameters,
     IFundingTransactionParameters,
     IInteractionParameters,
     ITransactionParameters,
 } from '../interfaces/ITransactionParameters.js';
-import { SupportedTransactionVersion } from '../interfaces/ITweakedTransactionData.js';
+import type { SupportedTransactionVersion } from '../interfaces/ITweakedTransactionData.js';
 
 /**
  * Options for reconstructing a transaction from serialized state
  */
 export interface ReconstructionOptions {
     /** Primary signer (used for normal mode or as default in rotation mode) */
-    signer: Signer | ECPairInterface;
+    signer: Signer | UniversalSigner;
 
     /** Optional: Override fee rate for fee bumping */
     newFeeRate?: number;
@@ -94,26 +107,22 @@ export class TransactionReconstructor {
             signer: options.signer,
             mldsaSigner: options.mldsaSigner ?? null,
             network,
-            chainId: state.header.chainId,
             utxos,
             optionalInputs,
             optionalOutputs,
             from: state.baseParams.from,
-            to: state.baseParams.to,
             feeRate,
             priorityFee,
             gasSatFee,
-            txVersion: state.baseParams.txVersion as SupportedTransactionVersion,
-            note: state.baseParams.note ? Buffer.from(state.baseParams.note, 'hex') : undefined,
             anchor: state.baseParams.anchor,
-            debugFees: state.baseParams.debugFees,
-            addressRotation,
-            estimatedFees: state.precomputedData.estimatedFees
-                ? BigInt(state.precomputedData.estimatedFees)
-                : undefined,
-            compiledTargetScript: state.precomputedData.compiledTargetScript
-                ? Buffer.from(state.precomputedData.compiledTargetScript, 'hex')
-                : undefined,
+            ...(state.header.chainId !== undefined ? { chainId: state.header.chainId } : {}),
+            ...(state.baseParams.to !== undefined ? { to: state.baseParams.to } : {}),
+            ...(state.baseParams.txVersion !== undefined ? { txVersion: state.baseParams.txVersion as SupportedTransactionVersion } : {}),
+            ...(state.baseParams.note !== undefined ? { note: fromHex(state.baseParams.note) } : {}),
+            ...(state.baseParams.debugFees !== undefined ? { debugFees: state.baseParams.debugFees } : {}),
+            ...(addressRotation !== undefined ? { addressRotation } : {}),
+            ...(state.precomputedData.estimatedFees !== undefined ? { estimatedFees: BigInt(state.precomputedData.estimatedFees) } : {}),
+            ...(state.precomputedData.compiledTargetScript !== undefined ? { compiledTargetScript: fromHex(state.precomputedData.compiledTargetScript) } : {}),
         };
 
         // Dispatch based on transaction type
@@ -164,14 +173,12 @@ export class TransactionReconstructor {
 
         const params: IDeploymentParameters = {
             ...baseParams,
-            bytecode: Buffer.from(data.bytecode, 'hex'),
-            calldata: data.calldata ? Buffer.from(data.calldata, 'hex') : undefined,
+            bytecode: fromHex(data.bytecode),
             challenge,
-            randomBytes: state.precomputedData.randomBytes
-                ? Buffer.from(state.precomputedData.randomBytes, 'hex')
-                : undefined,
-            revealMLDSAPublicKey: data.revealMLDSAPublicKey,
-            linkMLDSAPublicKeyToAddress: data.linkMLDSAPublicKeyToAddress,
+            ...(data.calldata !== undefined ? { calldata: fromHex(data.calldata) } : {}),
+            ...(state.precomputedData.randomBytes !== undefined ? { randomBytes: fromHex(state.precomputedData.randomBytes) } : {}),
+            ...(data.revealMLDSAPublicKey !== undefined ? { revealMLDSAPublicKey: data.revealMLDSAPublicKey } : {}),
+            ...(data.linkMLDSAPublicKeyToAddress !== undefined ? { linkMLDSAPublicKeyToAddress: data.linkMLDSAPublicKeyToAddress } : {}),
         };
 
         return new DeploymentTransaction(params);
@@ -194,17 +201,15 @@ export class TransactionReconstructor {
         const params: IInteractionParameters = {
             ...baseParams,
             to: baseParams.to,
-            calldata: Buffer.from(data.calldata, 'hex'),
-            contract: data.contract,
+            calldata: fromHex(data.calldata),
             challenge,
-            randomBytes: state.precomputedData.randomBytes
-                ? Buffer.from(state.precomputedData.randomBytes, 'hex')
-                : undefined,
-            loadedStorage: data.loadedStorage,
-            isCancellation: data.isCancellation,
-            disableAutoRefund: data.disableAutoRefund,
-            revealMLDSAPublicKey: data.revealMLDSAPublicKey,
-            linkMLDSAPublicKeyToAddress: data.linkMLDSAPublicKeyToAddress,
+            ...(data.contract !== undefined ? { contract: data.contract } : {}),
+            ...(state.precomputedData.randomBytes !== undefined ? { randomBytes: fromHex(state.precomputedData.randomBytes) } : {}),
+            ...(data.loadedStorage !== undefined ? { loadedStorage: data.loadedStorage } : {}),
+            ...(data.isCancellation !== undefined ? { isCancellation: data.isCancellation } : {}),
+            ...(data.disableAutoRefund !== undefined ? { disableAutoRefund: data.disableAutoRefund } : {}),
+            ...(data.revealMLDSAPublicKey !== undefined ? { revealMLDSAPublicKey: data.revealMLDSAPublicKey } : {}),
+            ...(data.linkMLDSAPublicKeyToAddress !== undefined ? { linkMLDSAPublicKeyToAddress: data.linkMLDSAPublicKeyToAddress } : {}),
         };
 
         return new InteractionTransaction(params);
@@ -217,17 +222,14 @@ export class TransactionReconstructor {
         baseParams: ITransactionParameters,
         data: MultiSigSpecificData,
     ): MultiSignTransaction {
-        const pubkeys = data.pubkeys.map((pk) => Buffer.from(pk, 'hex'));
+        const pubkeys = data.pubkeys.map((pk) => fromHex(pk));
 
         // If there's an existing PSBT, use fromBase64 to preserve partial signatures
         if (data.existingPsbtBase64) {
             return MultiSignTransaction.fromBase64({
                 mldsaSigner: baseParams.mldsaSigner,
                 network: baseParams.network,
-                chainId: baseParams.chainId,
                 utxos: baseParams.utxos,
-                optionalInputs: baseParams.optionalInputs,
-                optionalOutputs: baseParams.optionalOutputs,
                 feeRate: baseParams.feeRate,
                 pubkeys,
                 minimumSignatures: data.minimumSignatures,
@@ -235,6 +237,9 @@ export class TransactionReconstructor {
                 requestedAmount: BigInt(data.requestedAmount),
                 refundVault: data.refundVault,
                 psbt: data.existingPsbtBase64,
+                ...(baseParams.chainId !== undefined ? { chainId: baseParams.chainId } : {}),
+                ...(baseParams.optionalInputs !== undefined ? { optionalInputs: baseParams.optionalInputs } : {}),
+                ...(baseParams.optionalOutputs !== undefined ? { optionalOutputs: baseParams.optionalOutputs } : {}),
             });
         }
 
@@ -242,16 +247,16 @@ export class TransactionReconstructor {
         const params = {
             mldsaSigner: baseParams.mldsaSigner,
             network: baseParams.network,
-            chainId: baseParams.chainId,
             utxos: baseParams.utxos,
-            optionalInputs: baseParams.optionalInputs,
-            optionalOutputs: baseParams.optionalOutputs,
             feeRate: baseParams.feeRate,
             pubkeys,
             minimumSignatures: data.minimumSignatures,
             receiver: data.receiver,
             requestedAmount: BigInt(data.requestedAmount),
             refundVault: data.refundVault,
+            ...(baseParams.chainId !== undefined ? { chainId: baseParams.chainId } : {}),
+            ...(baseParams.optionalInputs !== undefined ? { optionalInputs: baseParams.optionalInputs } : {}),
+            ...(baseParams.optionalOutputs !== undefined ? { optionalOutputs: baseParams.optionalOutputs } : {}),
         };
 
         return new MultiSignTransaction(params);
@@ -265,17 +270,16 @@ export class TransactionReconstructor {
         data: CustomScriptSpecificData,
         state: ISerializableTransactionState,
     ): CustomScriptTransaction {
-        // Convert serialized elements to (Buffer | Stack)[]
-        const scriptElements: (Buffer | Stack)[] = data.scriptElements.map((el) => {
+        // Convert serialized elements to (Uint8Array | Stack)[]
+        const scriptElements: (Uint8Array | Stack)[] = data.scriptElements.map((el) => {
             if (el.elementType === 'buffer') {
-                return Buffer.from(el.value as string, 'hex');
+                return fromHex(el.value as string);
             }
             // Opcodes stored as numbers - wrap in array for Stack type
             return [el.value as number] as Stack;
         });
 
-        const witnesses = data.witnesses.map((w) => Buffer.from(w, 'hex'));
-        const annex = data.annex ? Buffer.from(data.annex, 'hex') : undefined;
+        const witnesses = data.witnesses.map((w) => fromHex(w));
 
         if (!baseParams.to) {
             throw new Error('CustomScriptTransaction requires a "to" address');
@@ -286,10 +290,8 @@ export class TransactionReconstructor {
             to: baseParams.to,
             script: scriptElements,
             witnesses,
-            annex,
-            randomBytes: state.precomputedData.randomBytes
-                ? Buffer.from(state.precomputedData.randomBytes, 'hex')
-                : undefined,
+            ...(data.annex !== undefined ? { annex: fromHex(data.annex) } : {}),
+            ...(state.precomputedData.randomBytes !== undefined ? { randomBytes: fromHex(state.precomputedData.randomBytes) } : {}),
         };
 
         return new CustomScriptTransaction(params);
@@ -304,7 +306,7 @@ export class TransactionReconstructor {
     ): CancelTransaction {
         const params = {
             ...baseParams,
-            compiledTargetScript: Buffer.from(data.compiledTargetScript, 'hex'),
+            compiledTargetScript: fromHex(data.compiledTargetScript),
         };
 
         return new CancelTransaction(params);
@@ -337,18 +339,21 @@ export class TransactionReconstructor {
      * Deserialize UTXOs from serialized format
      */
     private static deserializeUTXOs(serialized: SerializedUTXO[]): UTXO[] {
-        return serialized.map((s) => ({
-            transactionId: s.transactionId,
-            outputIndex: s.outputIndex,
-            value: BigInt(s.value),
-            scriptPubKey: {
-                hex: s.scriptPubKeyHex,
-                address: s.scriptPubKeyAddress,
-            },
-            redeemScript: s.redeemScript ? Buffer.from(s.redeemScript, 'hex') : undefined,
-            witnessScript: s.witnessScript ? Buffer.from(s.witnessScript, 'hex') : undefined,
-            nonWitnessUtxo: s.nonWitnessUtxo ? Buffer.from(s.nonWitnessUtxo, 'hex') : undefined,
-        }));
+        return serialized.map((s) => {
+            const utxo: UTXO = {
+                transactionId: s.transactionId,
+                outputIndex: s.outputIndex,
+                value: BigInt(s.value),
+                scriptPubKey: {
+                    hex: s.scriptPubKeyHex,
+                    ...(s.scriptPubKeyAddress !== undefined ? { address: s.scriptPubKeyAddress } : {}),
+                },
+            };
+            if (s.redeemScript !== undefined) utxo.redeemScript = fromHex(s.redeemScript);
+            if (s.witnessScript !== undefined) utxo.witnessScript = fromHex(s.witnessScript);
+            if (s.nonWitnessUtxo !== undefined) utxo.nonWitnessUtxo = fromHex(s.nonWitnessUtxo);
+            return utxo;
+        });
     }
 
     /**
@@ -356,30 +361,17 @@ export class TransactionReconstructor {
      */
     private static deserializeOutputs(serialized: SerializedOutput[]): PsbtOutputExtended[] {
         return serialized.map((s): PsbtOutputExtended => {
-            const tapInternalKey = s.tapInternalKey
-                ? Buffer.from(s.tapInternalKey, 'hex')
-                : undefined;
+            const base = { value: toSatoshi(BigInt(s.value)) };
+            const tapKey = s.tapInternalKey !== undefined ? { tapInternalKey: fromHex(s.tapInternalKey) } : {};
 
             // PsbtOutputExtended is a union type - either has address OR script, not both
             if (s.address) {
-                return {
-                    value: s.value,
-                    address: s.address,
-                    tapInternalKey,
-                };
+                return { ...base, address: s.address, ...tapKey };
             } else if (s.script) {
-                return {
-                    value: s.value,
-                    script: Buffer.from(s.script, 'hex'),
-                    tapInternalKey,
-                };
+                return { ...base, script: fromHex(s.script) as Script, ...tapKey };
             } else {
                 // Fallback - shouldn't happen with valid data
-                return {
-                    value: s.value,
-                    address: '',
-                    tapInternalKey,
-                };
+                return { ...base, address: '', ...tapKey };
             }
         });
     }