@btc-vision/transaction 1.7.19 → 1.7.23

package/browser/transaction/interfaces/IConsolidatedTransactionParameters.d.ts

@@ -0,0 +1,31 @@
+import { IInteractionParameters } from './ITransactionParameters.js';
+import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
+export interface IHashCommittedP2WSH extends IP2WSHAddress {
+    readonly dataHashes: Buffer[];
+    readonly dataChunks: Buffer[];
+    readonly chunkStartIndex: number;
+    readonly scriptPubKey: Buffer;
+}
+export interface IConsolidatedInteractionParameters extends IInteractionParameters {
+    readonly maxChunkSize?: number;
+}
+export interface ISetupTransactionResult {
+    readonly txHex: string;
+    readonly txId: string;
+    readonly outputs: IHashCommittedP2WSH[];
+    readonly feesPaid: bigint;
+    readonly chunkCount: number;
+    readonly totalDataSize: number;
+}
+export interface IRevealTransactionResult {
+    readonly txHex: string;
+    readonly txId: string;
+    readonly dataSize: number;
+    readonly feesPaid: bigint;
+    readonly inputCount: number;
+}
+export interface IConsolidatedInteractionResult {
+    readonly setup: ISetupTransactionResult;
+    readonly reveal: IRevealTransactionResult;
+    readonly totalFees: bigint;
+}

package/browser/transaction/interfaces/ITransactionParameters.d.ts

@@ -1,8 +1,9 @@
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { ITweakedTransactionData } from '../shared/TweakedTransaction.js';
 import { ChainId } from '../../network/ChainId.js';
-import { PsbtOutputExtended } from '@btc-vision/bitcoin';
+import { PsbtOutputExtended } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
+import { AddressRotationConfig } from '../../signer/AddressRotation.js';
 export interface LoadedStorage {
     [key: string]: string[];
 }
@@ -25,6 +26,7 @@ export interface ITransactionParameters extends ITweakedTransactionData {
     readonly priorityFee: bigint;
     readonly gasSatFee: bigint;
     readonly compiledTargetScript?: Buffer | string;
+    readonly addressRotation?: AddressRotationConfig;
 }
 export interface IFundingTransactionParameters extends ITransactionParameters {
     amount: bigint;

package/browser/transaction/interfaces/Tap.d.ts

@@ -1,4 +1,4 @@
-import { PsbtInput as _PsbtInput, PsbtInputUpdate as _PsbtInputUpdate, PsbtOutput as _PsbtOutput, TapBip32Derivation as _TapBip32Derivation, TapInternalKey as _TapInternalKey, TapKeySig as _TapKeySig, TapLeaf as _TapLeaf, TapLeafScript as _TapLeafScript, TapMerkleRoot as _TapMerkleRoot, TapScriptSig as _TapScriptSig, TapTree as _TapTree } from '@btc-vision/bitcoin';
+import { PsbtInput as _PsbtInput, PsbtInputUpdate as _PsbtInputUpdate, PsbtOutput as _PsbtOutput, TapBip32Derivation as _TapBip32Derivation, TapInternalKey as _TapInternalKey, TapKeySig as _TapKeySig, TapLeaf as _TapLeaf, TapLeafScript as _TapLeafScript, TapMerkleRoot as _TapMerkleRoot, TapScriptSig as _TapScriptSig, TapTree as _TapTree } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 export interface TapLeafScript {
     readonly leafVersion: number;
     readonly controlBlock: Buffer;

package/browser/transaction/mineable/TimelockGenerator.d.ts

@@ -1,4 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
+import { Network } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { IP2WSHAddress } from './IP2WSHAddress.js';
 export declare class TimeLockGenerator {
     private static readonly UNSPENDABLE_INTERNAL_KEY;

package/browser/transaction/offline/OfflineTransactionManager.d.ts

@@ -0,0 +1,69 @@
+import { Signer } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
+import { ECPairInterface } from 'ecpair';
+import { TransactionType } from '../enums/TransactionType.js';
+import { TransactionBuilder } from '../builders/TransactionBuilder.js';
+import { ISerializableTransactionState, PrecomputedData } from './interfaces/ISerializableState.js';
+import { ReconstructionOptions } from './TransactionReconstructor.js';
+import { IDeploymentParameters, IFundingTransactionParameters, IInteractionParameters, ITransactionParameters } from '../interfaces/ITransactionParameters.js';
+export interface ExportOptions {
+    params: ITransactionParameters;
+    type: TransactionType;
+    precomputed?: Partial<PrecomputedData>;
+}
+export declare class OfflineTransactionManager {
+    static exportFunding(params: IFundingTransactionParameters, precomputed?: Partial<PrecomputedData>): string;
+    static exportDeployment(params: IDeploymentParameters, precomputed: Partial<PrecomputedData> & {
+        compiledTargetScript: string;
+        randomBytes: string;
+    }): string;
+    static exportInteraction(params: IInteractionParameters, precomputed: Partial<PrecomputedData> & {
+        compiledTargetScript: string;
+        randomBytes: string;
+    }): string;
+    static exportMultiSig(params: ITransactionParameters & {
+        pubkeys: Buffer[];
+        minimumSignatures: number;
+        receiver: string;
+        requestedAmount: bigint;
+        refundVault: string;
+        originalInputCount?: number;
+        existingPsbtBase64?: string;
+    }, precomputed?: Partial<PrecomputedData>): string;
+    static exportCustomScript(params: ITransactionParameters & {
+        scriptElements: (Buffer | number)[];
+        witnesses: Buffer[];
+        annex?: Buffer;
+    }, precomputed?: Partial<PrecomputedData>): string;
+    static exportCancel(params: ITransactionParameters & {
+        compiledTargetScript: Buffer | string;
+    }, precomputed?: Partial<PrecomputedData>): string;
+    static exportFromBuilder<T extends TransactionType>(builder: TransactionBuilder<T>, params: ITransactionParameters, precomputed?: Partial<PrecomputedData>): string;
+    static importForSigning(serializedState: string, options: ReconstructionOptions): TransactionBuilder<TransactionType>;
+    static signAndExport(builder: TransactionBuilder<TransactionType>): Promise<string>;
+    static importSignAndExport(serializedState: string, options: ReconstructionOptions): Promise<string>;
+    static rebuildWithNewFees(serializedState: string, newFeeRate: number): string;
+    static rebuildSignAndExport(serializedState: string, newFeeRate: number, options: ReconstructionOptions): Promise<string>;
+    static inspect(serializedState: string): ISerializableTransactionState;
+    static validate(serializedState: string): boolean;
+    static getType(serializedState: string): TransactionType;
+    static fromBase64(base64State: string): ISerializableTransactionState;
+    static toBase64(state: ISerializableTransactionState): string;
+    static toHex(serializedState: string): string;
+    static fromHex(hexState: string): string;
+    static multiSigAddSignature(serializedState: string, signer: Signer | ECPairInterface): Promise<{
+        state: string;
+        signed: boolean;
+        final: boolean;
+        psbtBase64: string;
+    }>;
+    static multiSigHasSigned(serializedState: string, signerPubKey: Buffer | string): boolean;
+    static multiSigGetSignatureStatus(serializedState: string): {
+        required: number;
+        collected: number;
+        isComplete: boolean;
+        signers: string[];
+    };
+    static multiSigFinalize(serializedState: string): string;
+    static multiSigGetPsbt(serializedState: string): string | null;
+    static multiSigUpdatePsbt(serializedState: string, psbtBase64: string): string;
+}

package/browser/transaction/offline/TransactionReconstructor.d.ts

@@ -0,0 +1,28 @@
+import { Signer } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
+import { ECPairInterface } from 'ecpair';
+import { QuantumBIP32Interface } from '../../../node_modules/@btc-vision/bip32/src/cjs/index.cjs';
+import { SignerMap } from '../../signer/AddressRotation.js';
+import { TransactionType } from '../enums/TransactionType.js';
+import { TransactionBuilder } from '../builders/TransactionBuilder.js';
+import { ISerializableTransactionState } from './interfaces/ISerializableState.js';
+export interface ReconstructionOptions {
+    signer: Signer | ECPairInterface;
+    newFeeRate?: number;
+    newPriorityFee?: bigint;
+    newGasSatFee?: bigint;
+    signerMap?: SignerMap;
+    mldsaSigner?: QuantumBIP32Interface | null;
+}
+export declare class TransactionReconstructor {
+    static reconstruct(state: ISerializableTransactionState, options: ReconstructionOptions): TransactionBuilder<TransactionType>;
+    private static reconstructFunding;
+    private static reconstructDeployment;
+    private static reconstructInteraction;
+    private static reconstructMultiSig;
+    private static reconstructCustomScript;
+    private static reconstructCancel;
+    private static buildAddressRotationConfig;
+    private static deserializeUTXOs;
+    private static deserializeOutputs;
+    private static nameToNetwork;
+}

package/browser/transaction/offline/TransactionSerializer.d.ts

@@ -0,0 +1,50 @@
+import { ISerializableTransactionState } from './interfaces/ISerializableState.js';
+export declare class TransactionSerializer {
+    static serialize(state: ISerializableTransactionState): Buffer;
+    static deserialize(data: Buffer): ISerializableTransactionState;
+    static toBase64(state: ISerializableTransactionState): string;
+    static fromBase64(base64: string): ISerializableTransactionState;
+    static toHex(state: ISerializableTransactionState): string;
+    static fromHex(hex: string): ISerializableTransactionState;
+    private static writeHeader;
+    private static readHeader;
+    private static writeBaseParams;
+    private static readBaseParams;
+    private static writeUTXOArray;
+    private static writeUTXO;
+    private static readUTXOArray;
+    private static readUTXO;
+    private static writeOutputArray;
+    private static writeOutput;
+    private static readOutputArray;
+    private static readOutput;
+    private static writeSignerMappings;
+    private static readSignerMappings;
+    private static writeTypeSpecificData;
+    private static readTypeSpecificData;
+    private static writeFundingData;
+    private static readFundingData;
+    private static writeDeploymentData;
+    private static readDeploymentData;
+    private static writeInteractionData;
+    private static readInteractionData;
+    private static writeMultiSigData;
+    private static readMultiSigData;
+    private static writeCustomScriptData;
+    private static writeScriptElement;
+    private static readCustomScriptData;
+    private static readScriptElement;
+    private static writeCancelData;
+    private static readCancelData;
+    private static writeChallenge;
+    private static writeChallengeVerification;
+    private static readChallenge;
+    private static readChallengeVerification;
+    private static writeLoadedStorage;
+    private static readLoadedStorage;
+    private static writePrecomputedData;
+    private static readPrecomputedData;
+    private static calculateChecksum;
+    private static networkNameToU8;
+    private static u8ToNetworkName;
+}

package/browser/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/browser/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/browser/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/browser/transaction/processor/PsbtTransaction.d.ts

@@ -1,4 +1,4 @@
-import { Network, Psbt, PsbtInputExtended, PsbtOutputExtended, Signer, Transaction } from '@btc-vision/bitcoin';
+import { Network, Psbt, PsbtInputExtended, PsbtOutputExtended, Signer, Transaction } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { ITweakedTransactionData, TweakedTransaction } from '../shared/TweakedTransaction.js';
 export interface PsbtTransactionData extends ITweakedTransactionData {
     readonly psbt: Psbt;

package/browser/transaction/shared/P2TR_MS.d.ts

@@ -1,4 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
+import { Network } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 export declare class P2TR_MS {
     static generateMultiSigAddress(pubKeys: Buffer[], minimumSignatureRequired: number, network?: Network): string;
 }

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

@@ -1,12 +1,13 @@
 import { Logger } from '@btc-vision/logger';
-import { Network, P2TRPayment, Psbt, PsbtInput, PsbtInputExtended, Signer, Transaction } from '@btc-vision/bitcoin';
+import { Network, P2TRPayment, Psbt, PsbtInput, PsbtInputExtended, Signer, Transaction } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { ECPairInterface } from 'ecpair';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { ChainId } from '../../network/ChainId.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
-import { Buffer } from 'buffer';
-import { QuantumBIP32Interface } from '@btc-vision/bip32';
+import { Buffer } from '../../../buffer';
+import { QuantumBIP32Interface } from '../../../node_modules/@btc-vision/bip32/src/cjs/index.cjs';
+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/browser/utxo/OPNetLimitedProvider.d.ts

@@ -1,4 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
+import { Network } from '../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { Wallet } from '../opnet.js';
 import { BroadcastResponse } from './interfaces/BroadcastResponse.js';
 import { FetchUTXOParams, FetchUTXOParamsMultiAddress, RawUTXOResponse, UTXO } from './interfaces/IUTXO.js';

package/browser/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;