@btc-vision/transaction 1.7.18 → 1.7.22

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/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/build/transaction/offline/index.js

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

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

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

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

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

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;