@btc-vision/transaction 1.7.18 → 1.7.22

package/build/transaction/offline/OfflineTransactionManager.js

@@ -0,0 +1,255 @@
+import { Psbt } from '@btc-vision/bitcoin';
+import { TransactionType } from '../enums/TransactionType.js';
+import { TransactionBuilder } from '../builders/TransactionBuilder.js';
+import { MultiSignTransaction } from '../builders/MultiSignTransaction.js';
+import { TransactionSerializer } from './TransactionSerializer.js';
+import { TransactionReconstructor } from './TransactionReconstructor.js';
+import { TransactionStateCapture } from './TransactionStateCapture.js';
+import { isMultiSigSpecificData } from './interfaces/ITypeSpecificData.js';
+export class OfflineTransactionManager {
+    static exportFunding(params, precomputed) {
+        const state = TransactionStateCapture.fromFunding(params, precomputed);
+        return TransactionSerializer.toBase64(state);
+    }
+    static exportDeployment(params, precomputed) {
+        const state = TransactionStateCapture.fromDeployment(params, precomputed);
+        return TransactionSerializer.toBase64(state);
+    }
+    static exportInteraction(params, precomputed) {
+        const state = TransactionStateCapture.fromInteraction(params, precomputed);
+        return TransactionSerializer.toBase64(state);
+    }
+    static exportMultiSig(params, precomputed) {
+        const state = TransactionStateCapture.fromMultiSig(params, precomputed);
+        return TransactionSerializer.toBase64(state);
+    }
+    static exportCustomScript(params, precomputed) {
+        const state = TransactionStateCapture.fromCustomScript(params, precomputed);
+        return TransactionSerializer.toBase64(state);
+    }
+    static exportCancel(params, precomputed) {
+        const state = TransactionStateCapture.fromCancel(params, precomputed);
+        return TransactionSerializer.toBase64(state);
+    }
+    static exportFromBuilder(builder, params, precomputed) {
+        const type = builder.type;
+        let state;
+        switch (type) {
+            case TransactionType.FUNDING:
+                state = TransactionStateCapture.fromFunding(params, precomputed);
+                break;
+            case TransactionType.DEPLOYMENT:
+                state = TransactionStateCapture.fromDeployment(params, precomputed);
+                break;
+            case TransactionType.INTERACTION:
+                state = TransactionStateCapture.fromInteraction(params, precomputed);
+                break;
+            default:
+                throw new Error(`Unsupported transaction type for export: ${type}`);
+        }
+        return TransactionSerializer.toBase64(state);
+    }
+    static importForSigning(serializedState, options) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        return TransactionReconstructor.reconstruct(state, options);
+    }
+    static async signAndExport(builder) {
+        const tx = await builder.signTransaction();
+        return tx.toHex();
+    }
+    static async importSignAndExport(serializedState, options) {
+        const builder = this.importForSigning(serializedState, options);
+        return this.signAndExport(builder);
+    }
+    static rebuildWithNewFees(serializedState, newFeeRate) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        const newState = {
+            ...state,
+            baseParams: {
+                ...state.baseParams,
+                feeRate: newFeeRate,
+            },
+        };
+        return TransactionSerializer.toBase64(newState);
+    }
+    static async rebuildSignAndExport(serializedState, newFeeRate, options) {
+        const builder = this.importForSigning(serializedState, {
+            ...options,
+            newFeeRate,
+        });
+        return this.signAndExport(builder);
+    }
+    static inspect(serializedState) {
+        return TransactionSerializer.fromBase64(serializedState);
+    }
+    static validate(serializedState) {
+        try {
+            TransactionSerializer.fromBase64(serializedState);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static getType(serializedState) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        return state.header.transactionType;
+    }
+    static fromBase64(base64State) {
+        return TransactionSerializer.fromBase64(base64State);
+    }
+    static toBase64(state) {
+        return TransactionSerializer.toBase64(state);
+    }
+    static toHex(serializedState) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        return TransactionSerializer.toHex(state);
+    }
+    static fromHex(hexState) {
+        const state = TransactionSerializer.fromHex(hexState);
+        return TransactionSerializer.toBase64(state);
+    }
+    static async multiSigAddSignature(serializedState, signer) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        if (!isMultiSigSpecificData(state.typeSpecificData)) {
+            throw new Error('State is not a multisig transaction');
+        }
+        const typeData = state.typeSpecificData;
+        const pubkeys = typeData.pubkeys.map((pk) => Buffer.from(pk, 'hex'));
+        let psbt;
+        const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
+        if (typeData.existingPsbtBase64) {
+            psbt = Psbt.fromBase64(typeData.existingPsbtBase64, { network });
+        }
+        else {
+            const builder = this.importForSigning(serializedState, {
+                signer,
+            });
+            psbt = await builder.signPSBT();
+        }
+        const minimums = [];
+        for (let i = typeData.originalInputCount; i < psbt.data.inputs.length; i++) {
+            minimums.push(typeData.minimumSignatures);
+        }
+        const result = MultiSignTransaction.signPartial(psbt, signer, typeData.originalInputCount, minimums);
+        const orderedPubKeys = [];
+        for (let i = typeData.originalInputCount; i < psbt.data.inputs.length; i++) {
+            orderedPubKeys.push(pubkeys);
+        }
+        MultiSignTransaction.attemptFinalizeInputs(psbt, typeData.originalInputCount, orderedPubKeys, result.final);
+        const newPsbtBase64 = psbt.toBase64();
+        const newState = {
+            ...state,
+            typeSpecificData: {
+                ...typeData,
+                existingPsbtBase64: newPsbtBase64,
+            },
+        };
+        return {
+            state: TransactionSerializer.toBase64(newState),
+            signed: result.signed,
+            final: result.final,
+            psbtBase64: newPsbtBase64,
+        };
+    }
+    static multiSigHasSigned(serializedState, signerPubKey) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        if (!isMultiSigSpecificData(state.typeSpecificData)) {
+            throw new Error('State is not a multisig transaction');
+        }
+        const typeData = state.typeSpecificData;
+        if (!typeData.existingPsbtBase64) {
+            return false;
+        }
+        const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
+        const psbt = Psbt.fromBase64(typeData.existingPsbtBase64, { network });
+        const pubKeyBuffer = Buffer.isBuffer(signerPubKey)
+            ? signerPubKey
+            : Buffer.from(signerPubKey, 'hex');
+        return MultiSignTransaction.verifyIfSigned(psbt, pubKeyBuffer);
+    }
+    static multiSigGetSignatureStatus(serializedState) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        if (!isMultiSigSpecificData(state.typeSpecificData)) {
+            throw new Error('State is not a multisig transaction');
+        }
+        const typeData = state.typeSpecificData;
+        const required = typeData.minimumSignatures;
+        if (!typeData.existingPsbtBase64) {
+            return {
+                required,
+                collected: 0,
+                isComplete: false,
+                signers: [],
+            };
+        }
+        const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
+        const psbt = Psbt.fromBase64(typeData.existingPsbtBase64, { network });
+        const signerSet = new Set();
+        for (let i = typeData.originalInputCount; i < psbt.data.inputs.length; i++) {
+            const input = psbt.data.inputs[i];
+            if (input.tapScriptSig) {
+                for (const sig of input.tapScriptSig) {
+                    signerSet.add(sig.pubkey.toString('hex'));
+                }
+            }
+            if (input.finalScriptWitness) {
+                const decoded = TransactionBuilder.readScriptWitnessToWitnessStack(input.finalScriptWitness);
+                for (let j = 0; j < decoded.length - 2; j += 3) {
+                    const pubKey = decoded[j + 2];
+                    signerSet.add(pubKey.toString('hex'));
+                }
+            }
+        }
+        const signers = Array.from(signerSet);
+        return {
+            required,
+            collected: signers.length,
+            isComplete: signers.length >= required,
+            signers,
+        };
+    }
+    static multiSigFinalize(serializedState) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        if (!isMultiSigSpecificData(state.typeSpecificData)) {
+            throw new Error('State is not a multisig transaction');
+        }
+        const typeData = state.typeSpecificData;
+        if (!typeData.existingPsbtBase64) {
+            throw new Error('No PSBT found in state - transaction has not been signed');
+        }
+        const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
+        const psbt = Psbt.fromBase64(typeData.existingPsbtBase64, { network });
+        const pubkeys = typeData.pubkeys.map((pk) => Buffer.from(pk, 'hex'));
+        const orderedPubKeys = [];
+        for (let i = typeData.originalInputCount; i < psbt.data.inputs.length; i++) {
+            orderedPubKeys.push(pubkeys);
+        }
+        const success = MultiSignTransaction.attemptFinalizeInputs(psbt, typeData.originalInputCount, orderedPubKeys, true);
+        if (!success) {
+            throw new Error('Failed to finalize multisig transaction - not enough signatures');
+        }
+        return psbt.extractTransaction(true, true).toHex();
+    }
+    static multiSigGetPsbt(serializedState) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        if (!isMultiSigSpecificData(state.typeSpecificData)) {
+            throw new Error('State is not a multisig transaction');
+        }
+        return state.typeSpecificData.existingPsbtBase64 || null;
+    }
+    static multiSigUpdatePsbt(serializedState, psbtBase64) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        if (!isMultiSigSpecificData(state.typeSpecificData)) {
+            throw new Error('State is not a multisig transaction');
+        }
+        const newState = {
+            ...state,
+            typeSpecificData: {
+                ...state.typeSpecificData,
+                existingPsbtBase64: psbtBase64,
+            },
+        };
+        return TransactionSerializer.toBase64(newState);
+    }
+}

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

@@ -0,0 +1,243 @@
+import { networks } from '@btc-vision/bitcoin';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
+import { FundingTransaction } from '../builders/FundingTransaction.js';
+import { DeploymentTransaction } from '../builders/DeploymentTransaction.js';
+import { InteractionTransaction } from '../builders/InteractionTransaction.js';
+import { MultiSignTransaction } from '../builders/MultiSignTransaction.js';
+import { CustomScriptTransaction } from '../builders/CustomScriptTransaction.js';
+import { CancelTransaction } from '../builders/CancelTransaction.js';
+import { isCancelSpecificData, isCustomScriptSpecificData, isDeploymentSpecificData, isFundingSpecificData, isInteractionSpecificData, isMultiSigSpecificData, } from './interfaces/ITypeSpecificData.js';
+export class TransactionReconstructor {
+    static reconstruct(state, options) {
+        const network = this.nameToNetwork(state.baseParams.networkName);
+        const utxos = this.deserializeUTXOs(state.utxos);
+        const optionalInputs = this.deserializeUTXOs(state.optionalInputs);
+        const optionalOutputs = this.deserializeOutputs(state.optionalOutputs);
+        const addressRotation = this.buildAddressRotationConfig(state.addressRotationEnabled, options.signerMap);
+        const feeRate = options.newFeeRate ?? state.baseParams.feeRate;
+        const priorityFee = options.newPriorityFee ?? BigInt(state.baseParams.priorityFee);
+        const gasSatFee = options.newGasSatFee ?? BigInt(state.baseParams.gasSatFee);
+        const baseParams = {
+            signer: options.signer,
+            mldsaSigner: options.mldsaSigner ?? null,
+            network,
+            chainId: state.header.chainId,
+            utxos,
+            optionalInputs,
+            optionalOutputs,
+            from: state.baseParams.from,
+            to: state.baseParams.to,
+            feeRate,
+            priorityFee,
+            gasSatFee,
+            txVersion: state.baseParams.txVersion,
+            note: state.baseParams.note ? Buffer.from(state.baseParams.note, 'hex') : undefined,
+            anchor: state.baseParams.anchor,
+            debugFees: state.baseParams.debugFees,
+            addressRotation,
+            estimatedFees: state.precomputedData.estimatedFees
+                ? BigInt(state.precomputedData.estimatedFees)
+                : undefined,
+            compiledTargetScript: state.precomputedData.compiledTargetScript
+                ? Buffer.from(state.precomputedData.compiledTargetScript, 'hex')
+                : undefined,
+        };
+        const typeData = state.typeSpecificData;
+        if (isFundingSpecificData(typeData)) {
+            return this.reconstructFunding(baseParams, typeData);
+        }
+        else if (isDeploymentSpecificData(typeData)) {
+            return this.reconstructDeployment(baseParams, typeData, state);
+        }
+        else if (isInteractionSpecificData(typeData)) {
+            return this.reconstructInteraction(baseParams, typeData, state);
+        }
+        else if (isMultiSigSpecificData(typeData)) {
+            return this.reconstructMultiSig(baseParams, typeData);
+        }
+        else if (isCustomScriptSpecificData(typeData)) {
+            return this.reconstructCustomScript(baseParams, typeData, state);
+        }
+        else if (isCancelSpecificData(typeData)) {
+            return this.reconstructCancel(baseParams, typeData);
+        }
+        throw new Error(`Unsupported transaction type: ${state.header.transactionType}`);
+    }
+    static reconstructFunding(baseParams, data) {
+        const params = {
+            ...baseParams,
+            amount: BigInt(data.amount),
+            splitInputsInto: data.splitInputsInto,
+        };
+        return new FundingTransaction(params);
+    }
+    static reconstructDeployment(baseParams, data, state) {
+        const challenge = new ChallengeSolution(data.challenge);
+        const params = {
+            ...baseParams,
+            bytecode: Buffer.from(data.bytecode, 'hex'),
+            calldata: data.calldata ? Buffer.from(data.calldata, 'hex') : undefined,
+            challenge,
+            randomBytes: state.precomputedData.randomBytes
+                ? Buffer.from(state.precomputedData.randomBytes, 'hex')
+                : undefined,
+            revealMLDSAPublicKey: data.revealMLDSAPublicKey,
+            linkMLDSAPublicKeyToAddress: data.linkMLDSAPublicKeyToAddress,
+        };
+        return new DeploymentTransaction(params);
+    }
+    static reconstructInteraction(baseParams, data, state) {
+        const challenge = new ChallengeSolution(data.challenge);
+        if (!baseParams.to) {
+            throw new Error('InteractionTransaction requires a "to" address');
+        }
+        const params = {
+            ...baseParams,
+            to: baseParams.to,
+            calldata: Buffer.from(data.calldata, 'hex'),
+            contract: data.contract,
+            challenge,
+            randomBytes: state.precomputedData.randomBytes
+                ? Buffer.from(state.precomputedData.randomBytes, 'hex')
+                : undefined,
+            loadedStorage: data.loadedStorage,
+            isCancellation: data.isCancellation,
+            disableAutoRefund: data.disableAutoRefund,
+            revealMLDSAPublicKey: data.revealMLDSAPublicKey,
+            linkMLDSAPublicKeyToAddress: data.linkMLDSAPublicKeyToAddress,
+        };
+        return new InteractionTransaction(params);
+    }
+    static reconstructMultiSig(baseParams, data) {
+        const pubkeys = data.pubkeys.map((pk) => Buffer.from(pk, 'hex'));
+        if (data.existingPsbtBase64) {
+            return MultiSignTransaction.fromBase64({
+                mldsaSigner: baseParams.mldsaSigner,
+                network: baseParams.network,
+                chainId: baseParams.chainId,
+                utxos: baseParams.utxos,
+                optionalInputs: baseParams.optionalInputs,
+                optionalOutputs: baseParams.optionalOutputs,
+                feeRate: baseParams.feeRate,
+                pubkeys,
+                minimumSignatures: data.minimumSignatures,
+                receiver: data.receiver,
+                requestedAmount: BigInt(data.requestedAmount),
+                refundVault: data.refundVault,
+                psbt: data.existingPsbtBase64,
+            });
+        }
+        const params = {
+            mldsaSigner: baseParams.mldsaSigner,
+            network: baseParams.network,
+            chainId: baseParams.chainId,
+            utxos: baseParams.utxos,
+            optionalInputs: baseParams.optionalInputs,
+            optionalOutputs: baseParams.optionalOutputs,
+            feeRate: baseParams.feeRate,
+            pubkeys,
+            minimumSignatures: data.minimumSignatures,
+            receiver: data.receiver,
+            requestedAmount: BigInt(data.requestedAmount),
+            refundVault: data.refundVault,
+        };
+        return new MultiSignTransaction(params);
+    }
+    static reconstructCustomScript(baseParams, data, state) {
+        const scriptElements = data.scriptElements.map((el) => {
+            if (el.elementType === 'buffer') {
+                return Buffer.from(el.value, 'hex');
+            }
+            return [el.value];
+        });
+        const witnesses = data.witnesses.map((w) => Buffer.from(w, 'hex'));
+        const annex = data.annex ? Buffer.from(data.annex, 'hex') : undefined;
+        if (!baseParams.to) {
+            throw new Error('CustomScriptTransaction requires a "to" address');
+        }
+        const params = {
+            ...baseParams,
+            to: baseParams.to,
+            script: scriptElements,
+            witnesses,
+            annex,
+            randomBytes: state.precomputedData.randomBytes
+                ? Buffer.from(state.precomputedData.randomBytes, 'hex')
+                : undefined,
+        };
+        return new CustomScriptTransaction(params);
+    }
+    static reconstructCancel(baseParams, data) {
+        const params = {
+            ...baseParams,
+            compiledTargetScript: Buffer.from(data.compiledTargetScript, 'hex'),
+        };
+        return new CancelTransaction(params);
+    }
+    static buildAddressRotationConfig(enabled, signerMap) {
+        if (!enabled) {
+            return undefined;
+        }
+        if (!signerMap || signerMap.size === 0) {
+            throw new Error('Address rotation enabled but no signerMap provided in reconstruction options');
+        }
+        return {
+            enabled: true,
+            signerMap,
+        };
+    }
+    static deserializeUTXOs(serialized) {
+        return serialized.map((s) => ({
+            transactionId: s.transactionId,
+            outputIndex: s.outputIndex,
+            value: BigInt(s.value),
+            scriptPubKey: {
+                hex: s.scriptPubKeyHex,
+                address: s.scriptPubKeyAddress,
+            },
+            redeemScript: s.redeemScript ? Buffer.from(s.redeemScript, 'hex') : undefined,
+            witnessScript: s.witnessScript ? Buffer.from(s.witnessScript, 'hex') : undefined,
+            nonWitnessUtxo: s.nonWitnessUtxo ? Buffer.from(s.nonWitnessUtxo, 'hex') : undefined,
+        }));
+    }
+    static deserializeOutputs(serialized) {
+        return serialized.map((s) => {
+            const tapInternalKey = s.tapInternalKey
+                ? Buffer.from(s.tapInternalKey, 'hex')
+                : undefined;
+            if (s.address) {
+                return {
+                    value: s.value,
+                    address: s.address,
+                    tapInternalKey,
+                };
+            }
+            else if (s.script) {
+                return {
+                    value: s.value,
+                    script: Buffer.from(s.script, 'hex'),
+                    tapInternalKey,
+                };
+            }
+            else {
+                return {
+                    value: s.value,
+                    address: '',
+                    tapInternalKey,
+                };
+            }
+        });
+    }
+    static nameToNetwork(name) {
+        switch (name) {
+            case 'mainnet':
+                return networks.bitcoin;
+            case 'testnet':
+                return networks.testnet;
+            case 'regtest':
+                return networks.regtest;
+            default:
+                throw new Error(`Unknown network: ${name}`);
+        }
+    }
+}

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