@btc-vision/transaction 1.7.18 → 1.7.22

package/browser/keypair/Address.d.ts

@@ -3,7 +3,6 @@ import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
 import { MLDSASecurityLevel } from '@btc-vision/bip32';
 export declare class Address extends Uint8Array {
     #private;
-    private legacyPublicKey;
     constructor(mldsaPublicKey?: ArrayLike<number>, publicKeyOrTweak?: ArrayLike<number>);
     get mldsaLevel(): MLDSASecurityLevel | undefined;
     set mldsaLevel(level: MLDSASecurityLevel);
@@ -11,6 +10,7 @@ export declare class Address extends Uint8Array {
     set originalMDLSAPublicKey(key: Buffer | Uint8Array);
     get originalPublicKey(): Uint8Array | undefined;
     get mldsaPublicKey(): Uint8Array | undefined;
+    private get legacyPublicKey();
     private get keyPair();
     static dead(): Address;
     static fromString(mldsaPublicKey: string, legacyPublicKey?: string): Address;
@@ -48,5 +48,7 @@ export declare class Address extends Uint8Array {
     p2op(network: Network): string;
     toTweakedHybridPublicKeyHex(): string;
     toTweakedHybridPublicKeyBuffer(): Buffer;
+    private setMldsaKey;
+    private ensureLegacyProcessed;
     private autoFormat;
 }

package/browser/opnet.d.ts

@@ -4,6 +4,7 @@ export * from './bytecode/Compressor.js';
 export * from './generators/builders/CalldataGenerator.js';
 export * from './generators/builders/CustomGenerator.js';
 export * from './generators/builders/DeploymentGenerator.js';
+export * from './generators/builders/HashCommitmentGenerator.js';
 export * from './generators/builders/LegacyCalldataGenerator.js';
 export * from './generators/builders/MultiSignGenerator.js';
 export * from './generators/builders/P2WDAGenerator.js';
@@ -27,10 +28,14 @@ export * from './generators/MLDSAData.js';
 export * from './metadata/ContractBaseMetadata.js';
 export * from './network/ChainId.js';
 export * from './signer/TweakedSigner.js';
+export * from './signer/AddressRotation.js';
 export * from './transaction/enums/TransactionType.js';
 export * from './transaction/interfaces/ITransactionParameters.js';
+export * from './transaction/interfaces/IConsolidatedTransactionParameters.js';
 export * from './transaction/interfaces/Tap.js';
 export * from './transaction/TransactionFactory.js';
+export * from './transaction/builders/CancelTransaction.js';
+export * from './transaction/builders/ConsolidatedInteractionTransaction.js';
 export * from './transaction/builders/CustomScriptTransaction.js';
 export * from './transaction/builders/DeploymentTransaction.js';
 export * from './transaction/builders/FundingTransaction.js';
@@ -39,7 +44,7 @@ export * from './transaction/builders/InteractionTransactionP2WDA.js';
 export * from './transaction/builders/MultiSignTransaction.js';
 export * from './transaction/builders/SharedInteractionTransaction.js';
 export * from './transaction/builders/TransactionBuilder.js';
-export * from './transaction/builders/CancelTransaction.js';
+export * from './transaction/offline/index.js';
 export * from './epoch/interfaces/IChallengeSolution.js';
 export * from './epoch/validator/EpochValidator.js';
 export * from './epoch/ChallengeSolution.js';

package/browser/signer/AddressRotation.d.ts

@@ -0,0 +1,12 @@
+import { Signer } from '@btc-vision/bitcoin';
+import { ECPairInterface } from 'ecpair';
+import { UnisatSigner } from '../transaction/browser/extensions/UnisatSigner.js';
+export type RotationSigner = Signer | ECPairInterface | UnisatSigner;
+export type SignerMap = Map<string, RotationSigner>;
+export interface AddressRotationConfig {
+    readonly enabled: boolean;
+    readonly signerMap: SignerMap;
+}
+export declare function createSignerMap(pairs: ReadonlyArray<readonly [string, RotationSigner]>): SignerMap;
+export declare function createAddressRotation(signers: SignerMap | ReadonlyArray<readonly [string, RotationSigner]>): AddressRotationConfig;
+export declare function disabledAddressRotation(): AddressRotationConfig;

package/browser/transaction/TransactionFactory.d.ts

@@ -8,6 +8,7 @@ import { IDeploymentParameters, IFundingTransactionParameters, IInteractionParam
 import { ICancelTransactionParametersWithoutSigner, ICustomTransactionWithoutSigner, InteractionParametersWithoutSigner } from './browser/Web3Provider.js';
 import { RawChallenge } from '../epoch/interfaces/IChallengeSolution.js';
 import { ICancelTransactionParameters } from './builders/CancelTransaction.js';
+import { IConsolidatedInteractionParameters } from './interfaces/IConsolidatedTransactionParameters.js';
 export interface DeploymentResult {
     readonly transaction: [string, string];
     readonly contractAddress: string;
@@ -48,6 +49,18 @@ export interface CancelledTransaction {
     readonly nextUTXOs: UTXO[];
     readonly inputUtxos: UTXO[];
 }
+export interface ConsolidatedInteractionResponse {
+    readonly setupTransaction: string;
+    readonly revealTransaction: string;
+    readonly setupTxId: string;
+    readonly revealTxId: string;
+    readonly totalFees: bigint;
+    readonly chunkCount: number;
+    readonly dataSize: number;
+    readonly challenge: RawChallenge;
+    readonly inputUtxos: UTXO[];
+    readonly compiledTargetScript: string;
+}
 export declare class TransactionFactory {
     debug: boolean;
     private readonly DUMMY_PUBKEY;
@@ -57,6 +70,7 @@ export declare class TransactionFactory {
     createCancellableTransaction(params: ICancelTransactionParameters | ICancelTransactionParametersWithoutSigner): Promise<CancelledTransaction>;
     createCustomScriptTransaction(interactionParameters: ICustomTransactionParameters | ICustomTransactionWithoutSigner): Promise<[string, string, UTXO[], UTXO[]]>;
     signInteraction(interactionParameters: IInteractionParameters | InteractionParametersWithoutSigner): Promise<InteractionResponse>;
+    signConsolidatedInteraction(interactionParameters: IConsolidatedInteractionParameters): Promise<ConsolidatedInteractionResponse>;
     signDeployment(deploymentParameters: IDeploymentParameters): Promise<DeploymentResult>;
     createBTCTransfer(parameters: IFundingTransactionParameters): Promise<BitcoinTransferResponse>;
     getAllNewUTXOs(original: TransactionBuilder<TransactionType>, tx: Transaction, to: string): UTXO[];

package/browser/transaction/builders/ConsolidatedInteractionTransaction.d.ts

@@ -0,0 +1,44 @@
+import { Buffer } from 'buffer';
+import { ECPairInterface } from 'ecpair';
+import { TransactionType } from '../enums/TransactionType.js';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { HashCommitmentGenerator } from '../../generators/builders/HashCommitmentGenerator.js';
+import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
+import { IConsolidatedInteractionParameters, IConsolidatedInteractionResult, IHashCommittedP2WSH, IRevealTransactionResult } from '../interfaces/IConsolidatedTransactionParameters.js';
+import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
+export declare class ConsolidatedInteractionTransaction extends TransactionBuilder<TransactionType.INTERACTION> {
+    readonly type: TransactionType.INTERACTION;
+    protected readonly contractAddress: string;
+    protected readonly contractSecret: Buffer;
+    protected readonly calldata: Buffer;
+    protected readonly challenge: ChallengeSolution;
+    protected readonly epochChallenge: IP2WSHAddress;
+    readonly randomBytes: Buffer;
+    protected readonly scriptSigner: ECPairInterface;
+    protected readonly calldataGenerator: CalldataGenerator;
+    protected readonly hashCommitmentGenerator: HashCommitmentGenerator;
+    protected readonly compiledTargetScript: Buffer;
+    protected readonly commitmentOutputs: IHashCommittedP2WSH[];
+    protected readonly disableAutoRefund: boolean;
+    protected readonly maxChunkSize: number;
+    private cachedValuePerOutput;
+    constructor(parameters: IConsolidatedInteractionParameters);
+    exportCompiledTargetScript(): Buffer;
+    getContractSecret(): Buffer;
+    getRndBytes(): Buffer;
+    getChallenge(): ChallengeSolution;
+    getCommitmentOutputs(): IHashCommittedP2WSH[];
+    getOutputCount(): number;
+    getTotalChunkCount(): number;
+    build(): Promise<IConsolidatedInteractionResult>;
+    protected buildTransaction(): Promise<void>;
+    buildRevealTransaction(setupTxId: string): IRevealTransactionResult;
+    private finalizeCommitmentInput;
+    private estimateRevealVBytes;
+    private calculateValuePerOutput;
+    getValuePerOutput(): bigint;
+    private getRefundAddress;
+    private generateFeatures;
+    private validateOutputCount;
+}

package/browser/transaction/enums/TransactionType.d.ts

@@ -5,5 +5,7 @@ export declare enum TransactionType {
     INTERACTION = 3,
     MULTI_SIG = 4,
     CUSTOM_CODE = 5,
-    CANCEL = 6
+    CANCEL = 6,
+    CONSOLIDATED_SETUP = 7,
+    CONSOLIDATED_REVEAL = 8
 }

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

@@ -3,6 +3,7 @@ import { ITweakedTransactionData } from '../shared/TweakedTransaction.js';
 import { ChainId } from '../../network/ChainId.js';
 import { PsbtOutputExtended } from '@btc-vision/bitcoin';
 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/offline/OfflineTransactionManager.d.ts

@@ -0,0 +1,69 @@
+import { Signer } from '@btc-vision/bitcoin';
+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 '@btc-vision/bitcoin';
+import { ECPairInterface } from 'ecpair';
+import { QuantumBIP32Interface } from '@btc-vision/bip32';
+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/index.d.ts

@@ -0,0 +1,5 @@
+export * from './interfaces/index.js';
+export { TransactionSerializer } from './TransactionSerializer.js';
+export { TransactionStateCapture, CaptureParams } from './TransactionStateCapture.js';
+export { TransactionReconstructor, ReconstructionOptions } from './TransactionReconstructor.js';
+export { OfflineTransactionManager, ExportOptions } from './OfflineTransactionManager.js';

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/offline/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ISerializableState.js';
+export * from './ITypeSpecificData.js';

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

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.7.18";
+export declare const version = "1.7.22";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.7.18';
+export const version = '1.7.22';