@btc-vision/transaction 1.7.19 → 1.7.23

package/build/transaction/offline/TransactionStateCapture.d.ts

@@ -0,0 +1,52 @@
+import { TransactionType } from '../enums/TransactionType.js';
+import { ISerializableTransactionState, PrecomputedData } from './interfaces/ISerializableState.js';
+import { IDeploymentParameters, IFundingTransactionParameters, IInteractionParameters, ITransactionParameters } from '../interfaces/ITransactionParameters.js';
+export interface CaptureParams {
+    params: ITransactionParameters;
+    type: TransactionType;
+    precomputed?: Partial<PrecomputedData>;
+}
+export declare class TransactionStateCapture {
+    static fromFunding(params: IFundingTransactionParameters, precomputed?: Partial<PrecomputedData>): ISerializableTransactionState;
+    static fromDeployment(params: IDeploymentParameters, precomputed: Partial<PrecomputedData> & {
+        compiledTargetScript: string;
+        randomBytes: string;
+    }): ISerializableTransactionState;
+    static fromInteraction(params: IInteractionParameters, precomputed: Partial<PrecomputedData> & {
+        compiledTargetScript: string;
+        randomBytes: string;
+    }): ISerializableTransactionState;
+    static fromMultiSig(params: ITransactionParameters & {
+        pubkeys: Buffer[];
+        minimumSignatures: number;
+        receiver: string;
+        requestedAmount: bigint;
+        refundVault: string;
+        originalInputCount?: number;
+        existingPsbtBase64?: string;
+    }, precomputed?: Partial<PrecomputedData>): ISerializableTransactionState;
+    static fromCustomScript(params: ITransactionParameters & {
+        scriptElements: (Buffer | number)[];
+        witnesses: Buffer[];
+        annex?: Buffer;
+    }, precomputed?: Partial<PrecomputedData>): ISerializableTransactionState;
+    static fromCancel(params: ITransactionParameters & {
+        compiledTargetScript: Buffer | string;
+    }, precomputed?: Partial<PrecomputedData>): ISerializableTransactionState;
+    private static captureState;
+    private static createHeader;
+    private static extractBaseParams;
+    private static extractSignerMappings;
+    private static extractTypeSpecificData;
+    private static extractFundingData;
+    private static extractDeploymentData;
+    private static extractInteractionData;
+    private static extractMultiSigData;
+    private static extractCustomScriptData;
+    private static extractCancelData;
+    private static buildPrecomputedData;
+    private static serializeUTXOs;
+    private static serializeOutputs;
+    private static networkToName;
+    private static networkToChainId;
+}

package/build/transaction/offline/TransactionStateCapture.js

@@ -0,0 +1,275 @@
+import { ChainId } from '../../network/ChainId.js';
+import { currentConsensus } from '../../consensus/ConsensusConfig.js';
+import { TransactionType } from '../enums/TransactionType.js';
+import { SERIALIZATION_FORMAT_VERSION, } from './interfaces/ISerializableState.js';
+export class TransactionStateCapture {
+    static fromFunding(params, precomputed) {
+        return this.captureState({
+            params,
+            type: TransactionType.FUNDING,
+            precomputed,
+        });
+    }
+    static fromDeployment(params, precomputed) {
+        return this.captureState({
+            params: params,
+            type: TransactionType.DEPLOYMENT,
+            precomputed,
+        });
+    }
+    static fromInteraction(params, precomputed) {
+        return this.captureState({
+            params,
+            type: TransactionType.INTERACTION,
+            precomputed,
+        });
+    }
+    static fromMultiSig(params, precomputed) {
+        return this.captureState({
+            params,
+            type: TransactionType.MULTI_SIG,
+            precomputed,
+        });
+    }
+    static fromCustomScript(params, precomputed) {
+        return this.captureState({
+            params,
+            type: TransactionType.CUSTOM_CODE,
+            precomputed,
+        });
+    }
+    static fromCancel(params, precomputed) {
+        return this.captureState({
+            params,
+            type: TransactionType.CANCEL,
+            precomputed,
+        });
+    }
+    static captureState(capture) {
+        const { params, type, precomputed } = capture;
+        return {
+            header: this.createHeader(type, params.network, params.chainId),
+            baseParams: this.extractBaseParams(params),
+            utxos: this.serializeUTXOs(params.utxos),
+            optionalInputs: this.serializeUTXOs(params.optionalInputs || []),
+            optionalOutputs: this.serializeOutputs(params.optionalOutputs || []),
+            addressRotationEnabled: params.addressRotation?.enabled ?? false,
+            signerMappings: this.extractSignerMappings(params),
+            typeSpecificData: this.extractTypeSpecificData(type, params),
+            precomputedData: this.buildPrecomputedData(precomputed),
+        };
+    }
+    static createHeader(type, network, chainId) {
+        return {
+            formatVersion: SERIALIZATION_FORMAT_VERSION,
+            consensusVersion: currentConsensus,
+            transactionType: type,
+            chainId: chainId ?? this.networkToChainId(network),
+            timestamp: Date.now(),
+        };
+    }
+    static extractBaseParams(params) {
+        const note = params.note
+            ? Buffer.isBuffer(params.note)
+                ? params.note.toString('hex')
+                : Buffer.from(params.note).toString('hex')
+            : undefined;
+        const priorityFee = params.priorityFee ?? 0n;
+        const gasSatFee = params.gasSatFee ?? 0n;
+        return {
+            from: params.from || '',
+            to: params.to,
+            feeRate: params.feeRate,
+            priorityFee: priorityFee.toString(),
+            gasSatFee: gasSatFee.toString(),
+            networkName: this.networkToName(params.network),
+            txVersion: params.txVersion ?? 2,
+            note,
+            anchor: params.anchor ?? false,
+            debugFees: params.debugFees,
+        };
+    }
+    static extractSignerMappings(params) {
+        if (!params.addressRotation?.enabled) {
+            return [];
+        }
+        const mappings = [];
+        const addressToIndices = new Map();
+        params.utxos.forEach((utxo, index) => {
+            const address = utxo.scriptPubKey?.address;
+            if (address) {
+                const existing = addressToIndices.get(address);
+                if (existing) {
+                    existing.push(index);
+                }
+                else {
+                    addressToIndices.set(address, [index]);
+                }
+            }
+        });
+        const utxoCount = params.utxos.length;
+        (params.optionalInputs || []).forEach((utxo, index) => {
+            const address = utxo.scriptPubKey?.address;
+            if (address) {
+                const existing = addressToIndices.get(address);
+                if (existing) {
+                    existing.push(utxoCount + index);
+                }
+                else {
+                    addressToIndices.set(address, [utxoCount + index]);
+                }
+            }
+        });
+        addressToIndices.forEach((indices, address) => {
+            mappings.push({ address, inputIndices: indices });
+        });
+        return mappings;
+    }
+    static extractTypeSpecificData(type, params) {
+        switch (type) {
+            case TransactionType.FUNDING:
+                return this.extractFundingData(params);
+            case TransactionType.DEPLOYMENT:
+                return this.extractDeploymentData(params);
+            case TransactionType.INTERACTION:
+                return this.extractInteractionData(params);
+            case TransactionType.MULTI_SIG:
+                return this.extractMultiSigData(params);
+            case TransactionType.CUSTOM_CODE:
+                return this.extractCustomScriptData(params);
+            case TransactionType.CANCEL:
+                return this.extractCancelData(params);
+            default:
+                throw new Error(`Unsupported transaction type: ${type}`);
+        }
+    }
+    static extractFundingData(params) {
+        return {
+            type: TransactionType.FUNDING,
+            amount: params.amount.toString(),
+            splitInputsInto: params.splitInputsInto ?? 1,
+        };
+    }
+    static extractDeploymentData(params) {
+        return {
+            type: TransactionType.DEPLOYMENT,
+            bytecode: params.bytecode.toString('hex'),
+            calldata: params.calldata?.toString('hex'),
+            challenge: params.challenge.toRaw(),
+            revealMLDSAPublicKey: params.revealMLDSAPublicKey,
+            linkMLDSAPublicKeyToAddress: params.linkMLDSAPublicKeyToAddress,
+        };
+    }
+    static extractInteractionData(params) {
+        return {
+            type: TransactionType.INTERACTION,
+            calldata: params.calldata.toString('hex'),
+            contract: params.contract,
+            challenge: params.challenge.toRaw(),
+            loadedStorage: params.loadedStorage,
+            isCancellation: params.isCancellation,
+            disableAutoRefund: params.disableAutoRefund,
+            revealMLDSAPublicKey: params.revealMLDSAPublicKey,
+            linkMLDSAPublicKeyToAddress: params.linkMLDSAPublicKeyToAddress,
+        };
+    }
+    static extractMultiSigData(params) {
+        return {
+            type: TransactionType.MULTI_SIG,
+            pubkeys: (params.pubkeys || []).map((pk) => pk.toString('hex')),
+            minimumSignatures: params.minimumSignatures || 0,
+            receiver: params.receiver || '',
+            requestedAmount: (params.requestedAmount || 0n).toString(),
+            refundVault: params.refundVault || '',
+            originalInputCount: params.originalInputCount || params.utxos.length,
+            existingPsbtBase64: params.existingPsbtBase64,
+        };
+    }
+    static extractCustomScriptData(params) {
+        const scriptElements = (params.scriptElements || []).map((element) => {
+            if (Buffer.isBuffer(element)) {
+                return {
+                    elementType: 'buffer',
+                    value: element.toString('hex'),
+                };
+            }
+            else {
+                return {
+                    elementType: 'opcode',
+                    value: element,
+                };
+            }
+        });
+        return {
+            type: TransactionType.CUSTOM_CODE,
+            scriptElements,
+            witnesses: (params.witnesses || []).map((w) => w.toString('hex')),
+            annex: params.annex?.toString('hex'),
+        };
+    }
+    static extractCancelData(params) {
+        const script = params.compiledTargetScript;
+        const scriptHex = script ? (Buffer.isBuffer(script) ? script.toString('hex') : script) : '';
+        return {
+            type: TransactionType.CANCEL,
+            compiledTargetScript: scriptHex,
+        };
+    }
+    static buildPrecomputedData(precomputed) {
+        return {
+            compiledTargetScript: precomputed?.compiledTargetScript,
+            randomBytes: precomputed?.randomBytes,
+            estimatedFees: precomputed?.estimatedFees,
+            contractSeed: precomputed?.contractSeed,
+            contractAddress: precomputed?.contractAddress,
+        };
+    }
+    static serializeUTXOs(utxos) {
+        return utxos.map((utxo) => ({
+            transactionId: utxo.transactionId,
+            outputIndex: utxo.outputIndex,
+            value: utxo.value.toString(),
+            scriptPubKeyHex: utxo.scriptPubKey.hex,
+            scriptPubKeyAddress: utxo.scriptPubKey.address,
+            redeemScript: utxo.redeemScript
+                ? Buffer.isBuffer(utxo.redeemScript)
+                    ? utxo.redeemScript.toString('hex')
+                    : utxo.redeemScript
+                : undefined,
+            witnessScript: utxo.witnessScript
+                ? Buffer.isBuffer(utxo.witnessScript)
+                    ? utxo.witnessScript.toString('hex')
+                    : utxo.witnessScript
+                : undefined,
+            nonWitnessUtxo: utxo.nonWitnessUtxo
+                ? Buffer.isBuffer(utxo.nonWitnessUtxo)
+                    ? utxo.nonWitnessUtxo.toString('hex')
+                    : utxo.nonWitnessUtxo
+                : undefined,
+        }));
+    }
+    static serializeOutputs(outputs) {
+        return outputs.map((output) => {
+            const address = 'address' in output ? output.address : undefined;
+            const script = 'script' in output ? output.script : undefined;
+            return {
+                value: output.value,
+                address,
+                script: script ? script.toString('hex') : undefined,
+                tapInternalKey: output.tapInternalKey
+                    ? output.tapInternalKey.toString('hex')
+                    : undefined,
+            };
+        });
+    }
+    static networkToName(network) {
+        if (network.bech32 === 'bc')
+            return 'mainnet';
+        if (network.bech32 === 'tb')
+            return 'testnet';
+        return 'regtest';
+    }
+    static networkToChainId(network) {
+        return ChainId.Bitcoin;
+    }
+}

package/build/transaction/offline/interfaces/ISerializableState.d.ts

@@ -0,0 +1,62 @@
+import { TransactionType } from '../../enums/TransactionType.js';
+import { ChainId } from '../../../network/ChainId.js';
+import { TypeSpecificData } from './ITypeSpecificData.js';
+export declare const SERIALIZATION_FORMAT_VERSION = 1;
+export declare const SERIALIZATION_MAGIC_BYTE = 66;
+export interface SerializationHeader {
+    readonly formatVersion: number;
+    readonly consensusVersion: number;
+    readonly transactionType: TransactionType;
+    readonly chainId: ChainId;
+    readonly timestamp: number;
+}
+export interface SerializedUTXO {
+    readonly transactionId: string;
+    readonly outputIndex: number;
+    readonly value: string;
+    readonly scriptPubKeyHex: string;
+    readonly scriptPubKeyAddress?: string;
+    readonly redeemScript?: string;
+    readonly witnessScript?: string;
+    readonly nonWitnessUtxo?: string;
+}
+export interface SerializedOutput {
+    readonly value: number;
+    readonly address?: string;
+    readonly script?: string;
+    readonly tapInternalKey?: string;
+}
+export interface SerializedSignerMapping {
+    readonly address: string;
+    readonly inputIndices: number[];
+}
+export interface SerializedBaseParams {
+    readonly from: string;
+    readonly to?: string;
+    readonly feeRate: number;
+    readonly priorityFee: string;
+    readonly gasSatFee: string;
+    readonly networkName: 'mainnet' | 'testnet' | 'regtest';
+    readonly txVersion: number;
+    readonly note?: string;
+    readonly anchor: boolean;
+    readonly debugFees?: boolean;
+}
+export interface PrecomputedData {
+    readonly compiledTargetScript?: string;
+    readonly randomBytes?: string;
+    readonly estimatedFees?: string;
+    readonly contractSeed?: string;
+    readonly contractAddress?: string;
+}
+export interface ISerializableTransactionState {
+    readonly header: SerializationHeader;
+    readonly baseParams: SerializedBaseParams;
+    readonly utxos: SerializedUTXO[];
+    readonly optionalInputs: SerializedUTXO[];
+    readonly optionalOutputs: SerializedOutput[];
+    readonly addressRotationEnabled: boolean;
+    readonly signerMappings: SerializedSignerMapping[];
+    readonly typeSpecificData: TypeSpecificData;
+    readonly precomputedData: PrecomputedData;
+}

package/build/transaction/offline/interfaces/ISerializableState.js

@@ -0,0 +1,2 @@
+export const SERIALIZATION_FORMAT_VERSION = 1;
+export const SERIALIZATION_MAGIC_BYTE = 0x42;

package/build/transaction/offline/interfaces/ITypeSpecificData.d.ts

@@ -0,0 +1,62 @@
+import { TransactionType } from '../../enums/TransactionType.js';
+import { RawChallenge } from '../../../epoch/interfaces/IChallengeSolution.js';
+export type TypeSpecificData = FundingSpecificData | DeploymentSpecificData | InteractionSpecificData | MultiSigSpecificData | CustomScriptSpecificData | CancelSpecificData;
+export interface FundingSpecificData {
+    readonly type: TransactionType.FUNDING;
+    readonly amount: string;
+    readonly splitInputsInto: number;
+}
+export interface DeploymentSpecificData {
+    readonly type: TransactionType.DEPLOYMENT;
+    readonly bytecode: string;
+    readonly calldata?: string;
+    readonly challenge: RawChallenge;
+    readonly revealMLDSAPublicKey?: boolean;
+    readonly linkMLDSAPublicKeyToAddress?: boolean;
+    readonly hashedPublicKey?: string;
+}
+export interface InteractionSpecificData {
+    readonly type: TransactionType.INTERACTION;
+    readonly calldata: string;
+    readonly contract?: string;
+    readonly challenge: RawChallenge;
+    readonly loadedStorage?: SerializedLoadedStorage;
+    readonly isCancellation?: boolean;
+    readonly disableAutoRefund?: boolean;
+    readonly revealMLDSAPublicKey?: boolean;
+    readonly linkMLDSAPublicKeyToAddress?: boolean;
+    readonly hashedPublicKey?: string;
+}
+export interface SerializedLoadedStorage {
+    [key: string]: string[];
+}
+export interface MultiSigSpecificData {
+    readonly type: TransactionType.MULTI_SIG;
+    readonly pubkeys: string[];
+    readonly minimumSignatures: number;
+    readonly receiver: string;
+    readonly requestedAmount: string;
+    readonly refundVault: string;
+    readonly originalInputCount: number;
+    readonly existingPsbtBase64?: string;
+}
+export interface SerializedScriptElement {
+    readonly elementType: 'buffer' | 'opcode';
+    readonly value: string | number;
+}
+export interface CustomScriptSpecificData {
+    readonly type: TransactionType.CUSTOM_CODE;
+    readonly scriptElements: SerializedScriptElement[];
+    readonly witnesses: string[];
+    readonly annex?: string;
+}
+export interface CancelSpecificData {
+    readonly type: TransactionType.CANCEL;
+    readonly compiledTargetScript: string;
+}
+export declare function isFundingSpecificData(data: TypeSpecificData): data is FundingSpecificData;
+export declare function isDeploymentSpecificData(data: TypeSpecificData): data is DeploymentSpecificData;
+export declare function isInteractionSpecificData(data: TypeSpecificData): data is InteractionSpecificData;
+export declare function isMultiSigSpecificData(data: TypeSpecificData): data is MultiSigSpecificData;
+export declare function isCustomScriptSpecificData(data: TypeSpecificData): data is CustomScriptSpecificData;
+export declare function isCancelSpecificData(data: TypeSpecificData): data is CancelSpecificData;

package/build/transaction/offline/interfaces/ITypeSpecificData.js

@@ -0,0 +1,19 @@
+import { TransactionType } from '../../enums/TransactionType.js';
+export function isFundingSpecificData(data) {
+    return data.type === TransactionType.FUNDING;
+}
+export function isDeploymentSpecificData(data) {
+    return data.type === TransactionType.DEPLOYMENT;
+}
+export function isInteractionSpecificData(data) {
+    return data.type === TransactionType.INTERACTION;
+}
+export function isMultiSigSpecificData(data) {
+    return data.type === TransactionType.MULTI_SIG;
+}
+export function isCustomScriptSpecificData(data) {
+    return data.type === TransactionType.CUSTOM_CODE;
+}
+export function isCancelSpecificData(data) {
+    return data.type === TransactionType.CANCEL;
+}

package/build/transaction/shared/TweakedTransaction.d.ts

@@ -7,6 +7,7 @@ import { ChainId } from '../../network/ChainId.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 import { Buffer } from 'buffer';
 import { QuantumBIP32Interface } from '@btc-vision/bip32';
+import { AddressRotationConfig, RotationSigner, SignerMap } from '../../signer/AddressRotation.js';
 export type SupportedTransactionVersion = 1 | 2 | 3;
 export interface ITweakedTransactionData {
     readonly mldsaSigner: QuantumBIP32Interface | null;
@@ -17,6 +18,7 @@ export interface ITweakedTransactionData {
     readonly noSignatures?: boolean;
     readonly unlockScript?: Buffer[];
     readonly txVersion?: SupportedTransactionVersion;
+    readonly addressRotation?: AddressRotationConfig;
 }
 export declare enum TransactionSequence {
     REPLACE_BY_FEE = 4294967293,
@@ -51,6 +53,10 @@ export declare abstract class TweakedTransaction extends Logger {
     protected txVersion: SupportedTransactionVersion;
     protected readonly _mldsaSigner: QuantumBIP32Interface | null;
     protected readonly _hashedPublicKey: Buffer | null;
+    protected readonly addressRotationEnabled: boolean;
+    protected readonly signerMap: SignerMap;
+    protected readonly inputSignerMap: Map<number, RotationSigner>;
+    protected readonly tweakedSignerCache: Map<number, ECPairInterface | undefined>;
     protected constructor(data: ITweakedTransactionData);
     protected get mldsaSigner(): QuantumBIP32Interface;
     protected get hashedPublicKey(): Buffer;
@@ -58,6 +64,7 @@ export declare abstract class TweakedTransaction extends Logger {
     static preEstimateTaprootTransactionFees(feeRate: bigint, numInputs: bigint, numOutputs: bigint, numWitnessElements: bigint, witnessElementSize: bigint, emptyWitness: bigint, taprootControlWitnessSize?: bigint, taprootScriptSize?: bigint): bigint;
     protected static signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, sighashTypes: number[]): void;
     protected static calculateSignHash(sighashTypes: number[]): number;
+    isAddressRotationEnabled(): boolean;
     ignoreSignatureError(): void;
     getScriptAddress(): string;
     getTransaction(): Transaction;
@@ -65,6 +72,10 @@ export declare abstract class TweakedTransaction extends Logger {
     disableRBF(): void;
     getTweakerHash(): Buffer | undefined;
     preEstimateTransactionFees(feeRate: bigint, numInputs: bigint, numOutputs: bigint, numSignatures: bigint, numPubkeys: bigint): bigint;
+    protected getSignerForInput(inputIndex: number): RotationSigner;
+    protected registerInputSigner(inputIndex: number, utxo: UTXO): void;
+    protected internalPubKeyToXOnlyForInput(inputIndex: number): Buffer;
+    protected getTweakedSignerForInput(inputIndex: number, useTweakedHash?: boolean): ECPairInterface | undefined;
     protected generateTapData(): P2TRPayment;
     protected generateScriptAddress(): P2TRPayment;
     protected getSignerKey(): Signer | ECPairInterface;
@@ -81,7 +92,7 @@ export declare abstract class TweakedTransaction extends Logger {
         redeemScript: Buffer;
         outputScript: Buffer;
     } | undefined;
-    protected generateP2SHP2PKHRedeemScript(inputAddr: string): {
+    protected generateP2SHP2PKHRedeemScript(inputAddr: string, inputIndex?: number): {
         redeemScript: Buffer;
         outputScript: Buffer;
     } | undefined;

package/build/transaction/shared/TweakedTransaction.js

@@ -36,6 +36,10 @@ export class TweakedTransaction extends Logger {
         this.txVersion = 2;
         this._mldsaSigner = null;
         this._hashedPublicKey = null;
+        this.addressRotationEnabled = false;
+        this.signerMap = new Map();
+        this.inputSignerMap = new Map();
+        this.tweakedSignerCache = new Map();
         this.customFinalizerP2SH = (inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH) => {
             const inputDecoded = this.inputs[inputIndex];
             if (isP2SH && input.partialSig && inputDecoded && inputDecoded.redeemScript) {
@@ -84,6 +88,10 @@ export class TweakedTransaction extends Logger {
             this._mldsaSigner = data.mldsaSigner;
             this._hashedPublicKey = MessageSigner.sha256(this._mldsaSigner.publicKey);
         }
+        if (data.addressRotation?.enabled) {
+            this.addressRotationEnabled = true;
+            this.signerMap = data.addressRotation.signerMap;
+        }
     }
     get mldsaSigner() {
         if (!this._mldsaSigner) {
@@ -153,6 +161,9 @@ export class TweakedTransaction extends Logger {
         }
         return signHash || 0;
     }
+    isAddressRotationEnabled() {
+        return this.addressRotationEnabled;
+    }
     ignoreSignatureError() {
         this.ignoreSignatureErrors = true;
     }
@@ -198,6 +209,53 @@ export class TweakedTransaction extends Logger {
         const vSize = weight / 4n;
         return vSize * feeRate;
     }
+    getSignerForInput(inputIndex) {
+        if (this.addressRotationEnabled) {
+            const inputSigner = this.inputSignerMap.get(inputIndex);
+            if (inputSigner) {
+                return inputSigner;
+            }
+        }
+        return this.signer;
+    }
+    registerInputSigner(inputIndex, utxo) {
+        if (!this.addressRotationEnabled) {
+            return;
+        }
+        if (utxo.signer) {
+            this.inputSignerMap.set(inputIndex, utxo.signer);
+            return;
+        }
+        const address = utxo.scriptPubKey?.address;
+        if (address && this.signerMap.has(address)) {
+            const signer = this.signerMap.get(address);
+            if (signer) {
+                this.inputSignerMap.set(inputIndex, signer);
+                return;
+            }
+        }
+    }
+    internalPubKeyToXOnlyForInput(inputIndex) {
+        const signer = this.getSignerForInput(inputIndex);
+        return toXOnly(Buffer.from(signer.publicKey));
+    }
+    getTweakedSignerForInput(inputIndex, useTweakedHash = false) {
+        if (!this.addressRotationEnabled) {
+            if (useTweakedHash) {
+                this.tweakSigner();
+                return this.tweakedSigner;
+            }
+            return this.getTweakedSigner(useTweakedHash);
+        }
+        const cacheKey = inputIndex * 2 + (useTweakedHash ? 1 : 0);
+        if (this.tweakedSignerCache.has(cacheKey)) {
+            return this.tweakedSignerCache.get(cacheKey);
+        }
+        const signer = this.getSignerForInput(inputIndex);
+        const tweaked = this.getTweakedSigner(useTweakedHash, signer);
+        this.tweakedSignerCache.set(cacheKey, tweaked);
+        return tweaked;
+    }
     generateTapData() {
         return {
             internalPubkey: this.internalPubKeyToXOnly(),
@@ -289,7 +347,8 @@ export class TweakedTransaction extends Logger {
                     const index = offset + j;
                     const input = batch[j];
                     try {
-                        promises.push(this.signInput(transaction, input, index, this.signer));
+                        const inputSigner = this.getSignerForInput(index);
+                        promises.push(this.signInput(transaction, input, index, inputSigner));
                     }
                     catch (e) {
                         this.log(`Failed to sign input ${index}: ${e.stack}`);
@@ -370,10 +429,13 @@ export class TweakedTransaction extends Logger {
         }
         return;
     }
-    generateP2SHP2PKHRedeemScript(inputAddr) {
-        const pubkey = Buffer.isBuffer(this.signer.publicKey)
-            ? this.signer.publicKey
-            : Buffer.from(this.signer.publicKey, 'hex');
+    generateP2SHP2PKHRedeemScript(inputAddr, inputIndex) {
+        const signer = this.addressRotationEnabled && inputIndex !== undefined
+            ? this.getSignerForInput(inputIndex)
+            : this.signer;
+        const pubkey = Buffer.isBuffer(signer.publicKey)
+            ? signer.publicKey
+            : Buffer.from(signer.publicKey, 'hex');
         const w = payments.p2wpkh({
             pubkey: pubkey,
             network: this.network,
@@ -432,7 +494,7 @@ export class TweakedTransaction extends Logger {
                 if (!utxo.scriptPubKey.address) {
                     throw new Error('Missing redeemScript and no address to regenerate it for P2SH UTXO');
                 }
-                const legacyScripts = this.generateP2SHP2PKHRedeemScript(utxo.scriptPubKey.address);
+                const legacyScripts = this.generateP2SHP2PKHRedeemScript(utxo.scriptPubKey.address, i);
                 if (!legacyScripts) {
                     throw new Error('Missing redeemScript for P2SH UTXO and unable to regenerate');
                 }
@@ -469,8 +531,13 @@ export class TweakedTransaction extends Logger {
                 if (inputSign)
                     input.sighashType = inputSign;
             }
-            this.tweakSigner();
-            input.tapInternalKey = this.internalPubKeyToXOnly();
+            if (this.addressRotationEnabled) {
+                input.tapInternalKey = this.internalPubKeyToXOnlyForInput(i);
+            }
+            else {
+                this.tweakSigner();
+                input.tapInternalKey = this.internalPubKeyToXOnly();
+            }
         }
         else if (isP2A(scriptPub)) {
             this.anchorInputIndices.add(i);

package/build/utxo/interfaces/IUTXO.d.ts

@@ -1,4 +1,5 @@
 import { ScriptPubKey } from '@btc-vision/bitcoin-rpc';
+import { RotationSigner } from '../../signer/AddressRotation.js';
 export interface UTXO {
     readonly transactionId: string;
     readonly outputIndex: number;
@@ -7,6 +8,7 @@ export interface UTXO {
     redeemScript?: string | Buffer;
     witnessScript?: string | Buffer;
     nonWitnessUtxo?: string | Buffer;
+    signer?: RotationSigner;
 }
 export interface FetchUTXOParams {
     readonly address: string;