@btc-vision/transaction 1.7.18 → 1.7.22

package/build/signer/AddressRotation.js

@@ -0,0 +1,16 @@
+export function createSignerMap(pairs) {
+    return new Map(pairs);
+}
+export function createAddressRotation(signers) {
+    const signerMap = signers instanceof Map ? signers : createSignerMap(signers);
+    return {
+        enabled: true,
+        signerMap,
+    };
+}
+export function disabledAddressRotation() {
+    return {
+        enabled: false,
+        signerMap: new Map(),
+    };
+}

package/build/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/build/transaction/TransactionFactory.js

@@ -10,6 +10,7 @@ import { InteractionTransactionP2WDA } from './builders/InteractionTransactionP2
 import { Address } from '../keypair/Address.js';
 import { BitcoinUtils } from '../utils/BitcoinUtils.js';
 import { CancelTransaction } from './builders/CancelTransaction.js';
+import { ConsolidatedInteractionTransaction } from './builders/ConsolidatedInteractionTransaction.js';
 export class TransactionFactory {
     constructor() {
         this.debug = false;
@@ -177,6 +178,41 @@ export class TransactionFactory {
             compiledTargetScript: interactionTx.exportCompiledTargetScript().toString('hex'),
         };
     }
+    async signConsolidatedInteraction(interactionParameters) {
+        if (!interactionParameters.to) {
+            throw new Error('Field "to" not provided.');
+        }
+        if (!interactionParameters.from) {
+            throw new Error('Field "from" not provided.');
+        }
+        if (!interactionParameters.utxos[0]) {
+            throw new Error('Missing at least one UTXO.');
+        }
+        if (!('signer' in interactionParameters)) {
+            throw new Error('Field "signer" not provided.');
+        }
+        if (!interactionParameters.challenge) {
+            throw new Error('Field "challenge" not provided.');
+        }
+        const inputs = this.parseOptionalInputs(interactionParameters.optionalInputs);
+        const consolidatedTx = new ConsolidatedInteractionTransaction({
+            ...interactionParameters,
+            optionalInputs: inputs,
+        });
+        const result = await consolidatedTx.build();
+        return {
+            setupTransaction: result.setup.txHex,
+            revealTransaction: result.reveal.txHex,
+            setupTxId: result.setup.txId,
+            revealTxId: result.reveal.txId,
+            totalFees: result.totalFees,
+            chunkCount: result.setup.chunkCount,
+            dataSize: result.setup.totalDataSize,
+            challenge: consolidatedTx.getChallenge().toRaw(),
+            inputUtxos: interactionParameters.utxos,
+            compiledTargetScript: consolidatedTx.exportCompiledTargetScript().toString('hex'),
+        };
+    }
     async signDeployment(deploymentParameters) {
         const opWalletDeployment = await this.detectDeploymentOPWallet(deploymentParameters);
         if (opWalletDeployment) {

package/build/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/build/transaction/builders/ConsolidatedInteractionTransaction.js

@@ -0,0 +1,259 @@
+import { Buffer } from 'buffer';
+import { Psbt, toXOnly } from '@btc-vision/bitcoin';
+import { TransactionType } from '../enums/TransactionType.js';
+import { MINIMUM_AMOUNT_REWARD, TransactionBuilder } from './TransactionBuilder.js';
+import { HashCommitmentGenerator } from '../../generators/builders/HashCommitmentGenerator.js';
+import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
+import { TimeLockGenerator } from '../mineable/TimelockGenerator.js';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
+import { Compressor } from '../../bytecode/Compressor.js';
+import { FeaturePriority, Features } from '../../generators/Features.js';
+import { AddressGenerator } from '../../generators/AddressGenerator.js';
+export class ConsolidatedInteractionTransaction extends TransactionBuilder {
+    constructor(parameters) {
+        super(parameters);
+        this.type = TransactionType.INTERACTION;
+        this.cachedValuePerOutput = null;
+        if (!parameters.to) {
+            throw new Error('Contract address (to) is required');
+        }
+        if (!parameters.contract) {
+            throw new Error('Contract secret (contract) is required');
+        }
+        if (!parameters.calldata) {
+            throw new Error('Calldata is required');
+        }
+        if (!parameters.challenge) {
+            throw new Error('Challenge solution is required');
+        }
+        this.contractAddress = parameters.to;
+        this.contractSecret = Buffer.from(parameters.contract.replace('0x', ''), 'hex');
+        this.disableAutoRefund = parameters.disableAutoRefund || false;
+        this.maxChunkSize = parameters.maxChunkSize ?? HashCommitmentGenerator.MAX_CHUNK_SIZE;
+        if (this.contractSecret.length !== 32) {
+            throw new Error('Invalid contract secret length. Expected 32 bytes.');
+        }
+        this.calldata = Compressor.compress(parameters.calldata);
+        this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
+        this.scriptSigner = EcKeyPair.fromSeedKeyPair(this.randomBytes, this.network);
+        this.challenge = parameters.challenge;
+        this.epochChallenge = TimeLockGenerator.generateTimeLockAddress(this.challenge.publicKey.originalPublicKeyBuffer(), this.network);
+        this.calldataGenerator = new CalldataGenerator(Buffer.from(this.signer.publicKey), toXOnly(Buffer.from(this.scriptSigner.publicKey)), this.network);
+        if (parameters.compiledTargetScript) {
+            if (Buffer.isBuffer(parameters.compiledTargetScript)) {
+                this.compiledTargetScript = parameters.compiledTargetScript;
+            }
+            else if (typeof parameters.compiledTargetScript === 'string') {
+                this.compiledTargetScript = Buffer.from(parameters.compiledTargetScript, 'hex');
+            }
+            else {
+                throw new Error('Invalid compiled target script format.');
+            }
+        }
+        else {
+            this.compiledTargetScript = this.calldataGenerator.compile(this.calldata, this.contractSecret, this.challenge, this.priorityFee, this.generateFeatures(parameters));
+        }
+        this.hashCommitmentGenerator = new HashCommitmentGenerator(Buffer.from(this.signer.publicKey), this.network);
+        this.commitmentOutputs = this.hashCommitmentGenerator.prepareChunks(this.compiledTargetScript, this.maxChunkSize);
+        this.validateOutputCount();
+        const totalChunks = this.commitmentOutputs.reduce((sum, output) => sum + output.dataChunks.length, 0);
+        this.log(`ConsolidatedInteractionTransaction: ${this.commitmentOutputs.length} outputs, ` +
+            `${totalChunks} chunks from ${this.compiledTargetScript.length} bytes compiled data`);
+        this.internalInit();
+    }
+    exportCompiledTargetScript() {
+        return this.compiledTargetScript;
+    }
+    getContractSecret() {
+        return this.contractSecret;
+    }
+    getRndBytes() {
+        return this.randomBytes;
+    }
+    getChallenge() {
+        return this.challenge;
+    }
+    getCommitmentOutputs() {
+        return this.commitmentOutputs;
+    }
+    getOutputCount() {
+        return this.commitmentOutputs.length;
+    }
+    getTotalChunkCount() {
+        return this.commitmentOutputs.reduce((sum, output) => sum + output.dataChunks.length, 0);
+    }
+    async build() {
+        const setupTx = await this.signTransaction();
+        const setupTxId = setupTx.getId();
+        const setup = {
+            txHex: setupTx.toHex(),
+            txId: setupTxId,
+            outputs: this.commitmentOutputs,
+            feesPaid: this.transactionFee,
+            chunkCount: this.getTotalChunkCount(),
+            totalDataSize: this.compiledTargetScript.length,
+        };
+        this.log(`Setup transaction: ${setup.txId}`);
+        const reveal = this.buildRevealTransaction(setupTxId);
+        return {
+            setup,
+            reveal,
+            totalFees: setup.feesPaid + reveal.feesPaid,
+        };
+    }
+    async buildTransaction() {
+        this.addInputsFromUTXO();
+        const valuePerOutput = this.calculateValuePerOutput();
+        for (const commitment of this.commitmentOutputs) {
+            this.addOutput({
+                value: Number(valuePerOutput),
+                address: commitment.address,
+            });
+        }
+        const totalCommitmentValue = BigInt(this.commitmentOutputs.length) * valuePerOutput;
+        const optionalAmount = this.addOptionalOutputsAndGetAmount();
+        await this.addRefundOutput(totalCommitmentValue + optionalAmount);
+    }
+    buildRevealTransaction(setupTxId) {
+        const revealPsbt = new Psbt({ network: this.network });
+        const valuePerOutput = this.calculateValuePerOutput();
+        for (let i = 0; i < this.commitmentOutputs.length; i++) {
+            const commitment = this.commitmentOutputs[i];
+            revealPsbt.addInput({
+                hash: setupTxId,
+                index: i,
+                witnessUtxo: {
+                    script: commitment.scriptPubKey,
+                    value: Number(valuePerOutput),
+                },
+                witnessScript: commitment.witnessScript,
+            });
+        }
+        const inputValue = BigInt(this.commitmentOutputs.length) * valuePerOutput;
+        const opnetFee = this.getTransactionOPNetFee();
+        const feeAmount = opnetFee < MINIMUM_AMOUNT_REWARD ? MINIMUM_AMOUNT_REWARD : opnetFee;
+        revealPsbt.addOutput({
+            address: this.epochChallenge.address,
+            value: Number(feeAmount),
+        });
+        const estimatedVBytes = this.estimateRevealVBytes();
+        const revealFee = BigInt(Math.ceil(estimatedVBytes * this.feeRate));
+        const changeValue = inputValue - feeAmount - revealFee;
+        if (changeValue > TransactionBuilder.MINIMUM_DUST) {
+            const refundAddress = this.getRefundAddress();
+            revealPsbt.addOutput({
+                address: refundAddress,
+                value: Number(changeValue),
+            });
+        }
+        for (let i = 0; i < this.commitmentOutputs.length; i++) {
+            revealPsbt.signInput(i, this.signer);
+        }
+        for (let i = 0; i < this.commitmentOutputs.length; i++) {
+            const commitment = this.commitmentOutputs[i];
+            revealPsbt.finalizeInput(i, (_inputIndex, input) => {
+                return this.finalizeCommitmentInput(input, commitment);
+            });
+        }
+        const revealTx = revealPsbt.extractTransaction();
+        const result = {
+            txHex: revealTx.toHex(),
+            txId: revealTx.getId(),
+            dataSize: this.compiledTargetScript.length,
+            feesPaid: revealFee,
+            inputCount: this.commitmentOutputs.length,
+        };
+        this.log(`Reveal transaction: ${result.txId}`);
+        return result;
+    }
+    finalizeCommitmentInput(input, commitment) {
+        if (!input.partialSig || input.partialSig.length === 0) {
+            throw new Error('No signature for commitment input');
+        }
+        if (!input.witnessScript) {
+            throw new Error('No witness script for commitment input');
+        }
+        const witnessStack = [
+            input.partialSig[0].signature,
+            ...commitment.dataChunks,
+            input.witnessScript,
+        ];
+        return {
+            finalScriptSig: undefined,
+            finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witnessStack),
+        };
+    }
+    estimateRevealVBytes() {
+        const inputCount = this.commitmentOutputs.length;
+        let witnessWeight = 0;
+        for (const commitment of this.commitmentOutputs) {
+            const numChunks = commitment.dataChunks.length;
+            const chunkDataWeight = numChunks * 80;
+            const scriptWeight = numChunks * 23 + 35;
+            const sigWeight = 72;
+            const overheadWeight = 20;
+            witnessWeight += 164 + chunkDataWeight + scriptWeight + sigWeight + overheadWeight;
+        }
+        const weight = 40 + witnessWeight + 200;
+        return Math.ceil(weight / 4);
+    }
+    calculateValuePerOutput() {
+        if (this.cachedValuePerOutput !== null) {
+            return this.cachedValuePerOutput;
+        }
+        const numOutputs = this.commitmentOutputs.length;
+        const opnetFee = this.getTransactionOPNetFee();
+        const feeAmount = opnetFee < MINIMUM_AMOUNT_REWARD ? MINIMUM_AMOUNT_REWARD : opnetFee;
+        const estimatedVBytes = this.estimateRevealVBytes();
+        const revealFee = BigInt(Math.ceil(estimatedVBytes * this.feeRate));
+        const totalNeeded = feeAmount + revealFee + TransactionBuilder.MINIMUM_DUST;
+        const valuePerOutput = BigInt(Math.ceil(Number(totalNeeded) / numOutputs));
+        const minValue = HashCommitmentGenerator.MIN_OUTPUT_VALUE;
+        this.cachedValuePerOutput = valuePerOutput > minValue ? valuePerOutput : minValue;
+        return this.cachedValuePerOutput;
+    }
+    getValuePerOutput() {
+        return this.calculateValuePerOutput();
+    }
+    getRefundAddress() {
+        if (this.from) {
+            return this.from;
+        }
+        return AddressGenerator.generatePKSH(this.signer.publicKey, this.network);
+    }
+    generateFeatures(parameters) {
+        const features = [];
+        if (parameters.loadedStorage) {
+            features.push({
+                priority: FeaturePriority.ACCESS_LIST,
+                opcode: Features.ACCESS_LIST,
+                data: parameters.loadedStorage,
+            });
+        }
+        const submission = parameters.challenge.getSubmission();
+        if (submission) {
+            features.push({
+                priority: FeaturePriority.EPOCH_SUBMISSION,
+                opcode: Features.EPOCH_SUBMISSION,
+                data: submission,
+            });
+        }
+        if (parameters.revealMLDSAPublicKey && !parameters.linkMLDSAPublicKeyToAddress) {
+            throw new Error('To reveal the MLDSA public key, you must set linkMLDSAPublicKeyToAddress to true.');
+        }
+        if (parameters.linkMLDSAPublicKeyToAddress) {
+            this.generateMLDSALinkRequest(parameters, features);
+        }
+        return features;
+    }
+    validateOutputCount() {
+        const maxInputs = HashCommitmentGenerator.calculateMaxInputsPerTx();
+        if (this.commitmentOutputs.length > maxInputs) {
+            const maxData = HashCommitmentGenerator.calculateMaxDataPerTx();
+            throw new Error(`Data too large: ${this.commitmentOutputs.length} P2WSH outputs needed, ` +
+                `max ${maxInputs} per standard transaction (~${Math.floor(maxData / 1024)}KB). ` +
+                `Compiled data: ${this.compiledTargetScript.length} bytes.`);
+        }
+    }
+}

package/build/transaction/builders/TransactionBuilder.js

@@ -620,6 +620,7 @@ export class TransactionBuilder extends TweakedTransaction {
             }
             for (let i = 0; i < this.utxos.length; i++) {
                 const utxo = this.utxos[i];
+                this.registerInputSigner(i, utxo);
                 const input = this.generatePsbtInputExtended(utxo, i);
                 this.addInput(input);
             }
@@ -627,6 +628,7 @@ export class TransactionBuilder extends TweakedTransaction {
         if (this.optionalInputs) {
             for (let i = this.utxos.length; i < this.optionalInputs.length + this.utxos.length; i++) {
                 const utxo = this.optionalInputs[i - this.utxos.length];
+                this.registerInputSigner(i, utxo);
                 const input = this.generatePsbtInputExtended(utxo, i, true);
                 this.addInput(input);
             }

package/build/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/build/transaction/enums/TransactionType.js

@@ -7,4 +7,6 @@ export var TransactionType;
     TransactionType[TransactionType["MULTI_SIG"] = 4] = "MULTI_SIG";
     TransactionType[TransactionType["CUSTOM_CODE"] = 5] = "CUSTOM_CODE";
     TransactionType[TransactionType["CANCEL"] = 6] = "CANCEL";
+    TransactionType[TransactionType["CONSOLIDATED_SETUP"] = 7] = "CONSOLIDATED_SETUP";
+    TransactionType[TransactionType["CONSOLIDATED_REVEAL"] = 8] = "CONSOLIDATED_REVEAL";
 })(TransactionType || (TransactionType = {}));

package/build/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/build/transaction/interfaces/IConsolidatedTransactionParameters.js

@@ -0,0 +1 @@
+export {};

package/build/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/build/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;
+}