@btc-vision/bitcoin 7.0.0-alpha.1 → 7.0.0-alpha.10

package/src/psbt/PsbtCache.ts

@@ -0,0 +1,325 @@
+import type { PsbtInput, PsbtOutput } from 'bip174';
+import * as bscript from '../script.js';
+import type { TaprootHashCache, Transaction } from '../transaction.js';
+import type { PublicKey, Satoshi, Script, XOnlyPublicKey } from '../types.js';
+import { isP2TR, isP2WPKH, pubkeyInScript } from './psbtutils.js';
+import { getMeaningfulScript, isPubkeyLike, isSigLike, scriptWitnessToWitnessStack, } from './utils.js';
+import type { GetScriptReturn, PrevOut, PsbtOpts } from './types.js';
+import { isFinalized } from './validation.js';
+import { isUnknownSegwitVersion } from '../address.js';
+
+/**
+ * Internal PSBT cache for computed values.
+ * Wraps all cache management previously handled by a plain interface + scattered helper functions.
+ */
+export class PsbtCache {
+    public readonly nonWitnessUtxoTxCache: Transaction[];
+    public readonly nonWitnessUtxoBufCache: Uint8Array[];
+    public readonly txInCache: Record<string, number>;
+    public readonly tx: Transaction;
+    public unsafeSignNonSegwit: boolean;
+    public hasSignatures: boolean;
+    public fee: number | undefined;
+    public feeRate: number | undefined;
+    public extractedTx: Transaction | undefined;
+    public prevOuts: readonly PrevOut[] | undefined;
+    public signingScripts: readonly Script[] | undefined;
+    public values: readonly Satoshi[] | undefined;
+    public taprootHashCache: TaprootHashCache | undefined;
+
+    public constructor(tx: Transaction) {
+        this.nonWitnessUtxoTxCache = [];
+        this.nonWitnessUtxoBufCache = [];
+        this.txInCache = {};
+        this.tx = tx;
+        this.unsafeSignNonSegwit = false;
+        this.hasSignatures = false;
+    }
+
+    /**
+     * Invalidates cached computed values.
+     * @param scope - 'full' clears everything (for input changes), 'outputs' clears fee/extract/taproot caches
+     */
+    public invalidate(scope: 'full' | 'outputs'): void {
+        this.fee = undefined;
+        this.feeRate = undefined;
+        this.extractedTx = undefined;
+        this.taprootHashCache = undefined;
+        if (scope === 'full') {
+            this.prevOuts = undefined;
+            this.signingScripts = undefined;
+            this.values = undefined;
+        }
+    }
+
+    public addNonWitnessTxCache(
+        input: PsbtInput,
+        inputIndex: number,
+        txFromBuffer: (buf: Uint8Array) => Transaction,
+    ): void {
+        if (!input.nonWitnessUtxo) throw new Error('nonWitnessUtxo is required');
+        if (input === null || input === Object.prototype) {
+            throw new Error('Invalid input object');
+        }
+        const nonWitnessUtxoBuf = input.nonWitnessUtxo;
+        this.nonWitnessUtxoBufCache[inputIndex] = nonWitnessUtxoBuf;
+        this.nonWitnessUtxoTxCache[inputIndex] = txFromBuffer(nonWitnessUtxoBuf);
+    }
+
+    public getNonWitnessUtxoTx(
+        input: PsbtInput,
+        inputIndex: number,
+        txFromBuffer: (buf: Uint8Array) => Transaction,
+    ): Transaction {
+        const cached = this.nonWitnessUtxoTxCache[inputIndex];
+        if (!cached) {
+            this.addNonWitnessTxCache(input, inputIndex, txFromBuffer);
+        }
+        return this.nonWitnessUtxoTxCache[inputIndex]!;
+    }
+
+    public getScriptFromUtxo(
+        inputIndex: number,
+        input: PsbtInput,
+        txFromBuffer: (buf: Uint8Array) => Transaction,
+    ): Script {
+        const { script } = this.getScriptAndAmountFromUtxo(inputIndex, input, txFromBuffer);
+        return script;
+    }
+
+    public getScriptAndAmountFromUtxo(
+        inputIndex: number,
+        input: PsbtInput,
+        txFromBuffer: (buf: Uint8Array) => Transaction,
+    ): { script: Script; value: Satoshi } {
+        if (input.witnessUtxo !== undefined) {
+            return {
+                script: input.witnessUtxo.script as Script,
+                value: input.witnessUtxo.value as Satoshi,
+            };
+        } else if (input.nonWitnessUtxo !== undefined) {
+            const nonWitnessUtxoTx = this.getNonWitnessUtxoTx(input, inputIndex, txFromBuffer);
+            const o = nonWitnessUtxoTx.outs[this.tx.ins[inputIndex]!.index]!;
+            return { script: o.script, value: o.value };
+        } else {
+            throw new Error("Can't find pubkey in input without Utxo data");
+        }
+    }
+
+    public computeFee(
+        inputs: PsbtInput[],
+        disableOutputChecks: boolean = false,
+        txFromBuffer?: (buf: Uint8Array) => Transaction,
+    ): number {
+        if (!inputs.every(isFinalized)) throw new Error('PSBT must be finalized to calculate fee');
+        if (this.fee !== undefined) return this.fee;
+        let tx: Transaction;
+        let mustFinalize = true;
+        if (this.extractedTx) {
+            tx = this.extractedTx;
+            mustFinalize = false;
+        } else {
+            tx = this.tx.clone();
+        }
+        const { fee } = this.finalizeAndComputeAmounts(
+            inputs,
+            tx,
+            mustFinalize,
+            disableOutputChecks,
+            txFromBuffer,
+        );
+        return fee;
+    }
+
+    public computeFeeRate(
+        inputs: PsbtInput[],
+        disableOutputChecks: boolean = false,
+        txFromBuffer?: (buf: Uint8Array) => Transaction,
+    ): number {
+        if (!inputs.every(isFinalized))
+            throw new Error('PSBT must be finalized to calculate fee rate');
+        if (this.feeRate !== undefined) return this.feeRate;
+        let tx: Transaction;
+        let mustFinalize = true;
+        if (this.extractedTx) {
+            tx = this.extractedTx;
+            mustFinalize = false;
+        } else {
+            tx = this.tx.clone();
+        }
+        const { feeRate } = this.finalizeAndComputeAmounts(
+            inputs,
+            tx,
+            mustFinalize,
+            disableOutputChecks,
+            txFromBuffer,
+        );
+        return feeRate;
+    }
+
+    public checkFees(opts: PsbtOpts): void {
+        const feeRate = this.feeRate;
+        if (!this.extractedTx) throw new Error('Transaction not extracted');
+        if (feeRate === undefined) throw new Error('Fee rate not computed');
+        const vsize = this.extractedTx.virtualSize();
+        const satoshis = feeRate * vsize;
+        if (feeRate >= opts.maximumFeeRate) {
+            throw new Error(
+                `Warning: You are paying around ${(satoshis / 1e8).toFixed(8)} in ` +
+                    `fees, which is ${feeRate} satoshi per byte for a transaction ` +
+                    `with a VSize of ${vsize} bytes (segwit counted as 0.25 byte per ` +
+                    `byte). Use setMaximumFeeRate method to raise your threshold, or ` +
+                    `pass true to the first arg of extractTransaction.`,
+            );
+        }
+    }
+
+    public pubkeyInInput(
+        pubkey: PublicKey,
+        input: PsbtInput,
+        inputIndex: number,
+        txFromBuffer: (buf: Uint8Array) => Transaction,
+    ): boolean {
+        const script = this.getScriptFromUtxo(inputIndex, input, txFromBuffer);
+        const { meaningfulScript } = getMeaningfulScript(
+            script,
+            inputIndex,
+            'input',
+            input.redeemScript,
+            input.witnessScript,
+        );
+        return pubkeyInScript(pubkey, meaningfulScript);
+    }
+
+    public pubkeyInOutput(pubkey: PublicKey, output: PsbtOutput, outputIndex: number): boolean {
+        const script = this.tx.outs[outputIndex]!.script;
+        const { meaningfulScript } = getMeaningfulScript(
+            script,
+            outputIndex,
+            'output',
+            output.redeemScript,
+            output.witnessScript,
+        );
+        return pubkeyInScript(pubkey, meaningfulScript);
+    }
+
+    public redeemFromFinalScriptSig(finalScript: Uint8Array | undefined): Uint8Array | undefined {
+        if (!finalScript) return;
+        const decomp = bscript.decompile(finalScript);
+        if (!decomp) return;
+        const lastItem = decomp[decomp.length - 1]!;
+        if (!(lastItem instanceof Uint8Array) || isPubkeyLike(lastItem) || isSigLike(lastItem))
+            return;
+        const sDecomp = bscript.decompile(lastItem);
+        if (!sDecomp) return;
+        return lastItem;
+    }
+
+    public redeemFromFinalWitnessScript(
+        finalScript: Uint8Array | undefined,
+    ): Uint8Array | undefined {
+        if (!finalScript) return;
+        const decomp = scriptWitnessToWitnessStack(finalScript);
+        const lastItem = decomp[decomp.length - 1]!;
+        if (isPubkeyLike(lastItem)) return;
+        const sDecomp = bscript.decompile(lastItem);
+        if (!sDecomp) return;
+        return lastItem;
+    }
+
+    /**
+     * Finalize transaction inputs and compute fee amounts.
+     * Returns computed values instead of mutating cache parameters directly.
+     */
+    public finalizeAndComputeAmounts(
+        inputs: PsbtInput[],
+        tx: Transaction,
+        mustFinalize: boolean,
+        disableOutputChecks?: boolean,
+        txFromBuffer?: (buf: Uint8Array) => Transaction,
+    ): { fee: number; feeRate: number } {
+        let inputAmount = 0n;
+        inputs.forEach((input, idx) => {
+            if (mustFinalize && input.finalScriptSig)
+                tx.ins[idx]!.script = input.finalScriptSig as Script;
+            if (mustFinalize && input.finalScriptWitness) {
+                tx.ins[idx]!.witness = scriptWitnessToWitnessStack(input.finalScriptWitness);
+            }
+            if (input.witnessUtxo) {
+                inputAmount += input.witnessUtxo.value;
+            } else if (input.nonWitnessUtxo) {
+                if (!txFromBuffer)
+                    throw new Error('txFromBuffer is required for nonWitnessUtxo inputs');
+                const nwTx = this.getNonWitnessUtxoTx(input, idx, txFromBuffer);
+                const vout = tx.ins[idx]!.index;
+                const out = nwTx.outs[vout]!;
+                inputAmount += out.value;
+            }
+        });
+        const outputAmount = tx.outs.reduce((total, o) => total + o.value, 0n);
+        const feeValue = inputAmount - outputAmount;
+        if (!disableOutputChecks) {
+            if (feeValue < 0n) {
+                throw new Error(
+                    `Outputs are spending more than Inputs ${inputAmount} < ${outputAmount}`,
+                );
+            }
+        }
+        const bytes = tx.virtualSize();
+        const fee = Number(feeValue);
+        const feeRate = Math.floor(fee / bytes);
+
+        this.fee = fee;
+        this.extractedTx = tx;
+        this.feeRate = feeRate;
+
+        return { fee, feeRate };
+    }
+
+    public getScriptFromInput(
+        inputIndex: number,
+        input: PsbtInput,
+        txFromBuffer: (buf: Uint8Array) => Transaction,
+    ): GetScriptReturn {
+        const res: GetScriptReturn = {
+            script: null,
+            isSegwit: false,
+            isP2SH: false,
+            isP2WSH: false,
+        };
+        res.isP2SH = !!input.redeemScript;
+        res.isP2WSH = !!input.witnessScript;
+        if (input.witnessScript) {
+            res.script = input.witnessScript as Script;
+        } else if (input.redeemScript) {
+            res.script = input.redeemScript as Script;
+        } else {
+            if (input.nonWitnessUtxo) {
+                const nonWitnessUtxoTx = this.getNonWitnessUtxoTx(input, inputIndex, txFromBuffer);
+                const prevoutIndex = this.tx.ins[inputIndex]!.index;
+                res.script = nonWitnessUtxoTx.outs[prevoutIndex]!.script;
+            } else if (input.witnessUtxo) {
+                res.script = input.witnessUtxo.script as Script;
+            }
+        }
+
+        if (input.witnessScript || (res.script && isP2WPKH(res.script))) {
+            res.isSegwit = true;
+        } else {
+            if (res.script && isUnknownSegwitVersion(res.script)) {
+                res.isSegwit = true;
+            }
+        }
+
+        return res;
+    }
+
+    public getPrevoutTaprootKey(
+        inputIndex: number,
+        input: PsbtInput,
+        txFromBuffer: (buf: Uint8Array) => Transaction,
+    ): XOnlyPublicKey | null {
+        const { script } = this.getScriptAndAmountFromUtxo(inputIndex, input, txFromBuffer);
+        return isP2TR(script) ? (script.subarray(2, 34) as XOnlyPublicKey) : null;
+    }
+}

package/src/psbt/PsbtFinalizer.ts

@@ -0,0 +1,213 @@
+import type { PartialSig, PsbtInput } from 'bip174';
+import { equals } from '../io/index.js';
+import type { P2SHPayment, P2WSHPayment, Payment } from '../payments/index.js';
+import * as payments from '../payments/index.js';
+import { witnessStackToScriptWitness } from './psbtutils.js';
+import { classifyScript, compressPubkey } from './utils.js';
+import type { Transaction } from '../transaction.js';
+import type { PublicKey, Script, Signature } from '../types.js';
+import type { PsbtCache } from './PsbtCache.js';
+import type { GetScriptReturn } from './types.js';
+
+export interface FinalScriptsResult {
+    readonly finalScriptSig: Script | undefined;
+    readonly finalScriptWitness: Uint8Array | undefined;
+}
+
+/**
+ * Class wrapping all finalization logic for PSBT.
+ */
+export class PsbtFinalizer {
+    readonly #cache: PsbtCache;
+    readonly #txFromBuffer: (buf: Uint8Array) => Transaction;
+
+    public constructor(cache: PsbtCache, txFromBuffer: (buf: Uint8Array) => Transaction) {
+        this.#cache = cache;
+        this.#txFromBuffer = txFromBuffer;
+    }
+
+    public getFinalScripts(
+        inputIndex: number,
+        input: PsbtInput,
+        script: Script,
+        isSegwit: boolean,
+        isP2SH: boolean,
+        isP2WSH: boolean,
+        canRunChecks: boolean = true,
+        solution?: Uint8Array[],
+    ): FinalScriptsResult {
+        const scriptType = classifyScript(script);
+        if (!canFinalize(input, script, scriptType) && canRunChecks) {
+            throw new Error(`Can not finalize input #${inputIndex}`);
+        }
+
+        if (!input.partialSig) throw new Error('Input missing partial signatures');
+        return prepareFinalScripts(
+            script,
+            scriptType,
+            input.partialSig,
+            isSegwit,
+            isP2SH,
+            isP2WSH,
+            solution,
+        );
+    }
+
+    public getScriptFromInput(inputIndex: number, input: PsbtInput): GetScriptReturn {
+        return this.#cache.getScriptFromInput(inputIndex, input, this.#txFromBuffer);
+    }
+}
+
+export function getFinalScripts(
+    inputIndex: number,
+    input: PsbtInput,
+    script: Script,
+    isSegwit: boolean,
+    isP2SH: boolean,
+    isP2WSH: boolean,
+    canRunChecks: boolean = true,
+    solution?: Uint8Array[],
+): FinalScriptsResult {
+    const scriptType = classifyScript(script);
+    if (!canFinalize(input, script, scriptType) && canRunChecks) {
+        throw new Error(`Can not finalize input #${inputIndex}`);
+    }
+
+    if (!input.partialSig) throw new Error('Input missing partial signatures');
+    return prepareFinalScripts(
+        script,
+        scriptType,
+        input.partialSig,
+        isSegwit,
+        isP2SH,
+        isP2WSH,
+        solution,
+    );
+}
+
+export function prepareFinalScripts(
+    script: Uint8Array,
+    scriptType: string,
+    partialSig: PartialSig[],
+    isSegwit: boolean,
+    isP2SH: boolean,
+    isP2WSH: boolean,
+    solution?: Uint8Array[],
+): FinalScriptsResult {
+    let finalScriptSig: Script | undefined;
+    let finalScriptWitness: Uint8Array | undefined;
+
+    const payment: Payment = getPayment(script, scriptType, partialSig);
+    const p2wsh = !isP2WSH ? null : payments.p2wsh({ redeem: payment } as P2WSHPayment);
+    const p2sh = !isP2SH ? null : payments.p2sh({ redeem: p2wsh || payment } as P2SHPayment);
+
+    if (isSegwit) {
+        if (p2wsh && p2wsh.witness) {
+            finalScriptWitness = witnessStackToScriptWitness(p2wsh.witness);
+        } else if (payment && payment.witness) {
+            finalScriptWitness = witnessStackToScriptWitness(payment.witness);
+        } else {
+            finalScriptWitness = witnessStackToScriptWitness(solution ?? [new Uint8Array([0x00])]);
+        }
+        if (p2sh) {
+            finalScriptSig = p2sh?.input;
+        }
+    } else {
+        if (p2sh) {
+            finalScriptSig = p2sh?.input;
+        } else {
+            if (!payment) {
+                finalScriptSig = (
+                    Array.isArray(solution) && solution[0] ? solution[0] : new Uint8Array([0x01])
+                ) as Script;
+            } else {
+                finalScriptSig = payment.input;
+            }
+        }
+    }
+    return { finalScriptSig, finalScriptWitness };
+}
+
+function canFinalize(input: PsbtInput, script: Uint8Array, scriptType: string): boolean {
+    switch (scriptType) {
+        case 'pubkey':
+        case 'pubkeyhash':
+        case 'witnesspubkeyhash':
+            return hasSigs(1, input.partialSig);
+        case 'multisig': {
+            const p2ms = payments.p2ms({
+                output: script as Script,
+            });
+            if (p2ms.m === undefined) throw new Error('Cannot determine m for multisig');
+            return hasSigs(p2ms.m, input.partialSig, p2ms.pubkeys);
+        }
+        case 'nonstandard':
+            return true;
+        default:
+            return false;
+    }
+}
+
+function hasSigs(neededSigs: number, partialSig?: PartialSig[], pubkeys?: Uint8Array[]): boolean {
+    if (!partialSig) return false;
+    let sigs: PartialSig[];
+    if (pubkeys) {
+        sigs = pubkeys
+            .map((pkey) => {
+                const pubkey = compressPubkey(pkey);
+                return partialSig.find((pSig) => equals(pSig.pubkey, pubkey));
+            })
+            .filter((v): v is PartialSig => !!v);
+    } else {
+        sigs = partialSig;
+    }
+    if (sigs.length > neededSigs) throw new Error('Too many signatures');
+    return sigs.length === neededSigs;
+}
+
+function getPayment(script: Uint8Array, scriptType: string, partialSig: PartialSig[]): Payment {
+    const scriptBranded = script as Script;
+    switch (scriptType) {
+        case 'multisig': {
+            const sigs = getSortedSigs(script, partialSig);
+            return payments.p2ms({
+                output: scriptBranded,
+                signatures: sigs as Signature[],
+            });
+        }
+        case 'pubkey':
+            return payments.p2pk({
+                output: scriptBranded,
+                signature: partialSig[0]!.signature as Signature,
+            });
+        case 'pubkeyhash':
+            return payments.p2pkh({
+                output: scriptBranded,
+                pubkey: partialSig[0]!.pubkey as PublicKey,
+                signature: partialSig[0]!.signature as Signature,
+            });
+        case 'witnesspubkeyhash':
+            return payments.p2wpkh({
+                output: scriptBranded,
+                pubkey: partialSig[0]!.pubkey as PublicKey,
+                signature: partialSig[0]!.signature as Signature,
+            });
+        default:
+            throw new Error(`Unknown script type: ${scriptType}`);
+    }
+}
+
+function getSortedSigs(script: Uint8Array, partialSig: PartialSig[]): Uint8Array[] {
+    const p2ms = payments.p2ms({ output: script as Script });
+    if (!p2ms.pubkeys) throw new Error('Cannot extract pubkeys from multisig script');
+    const result: Uint8Array[] = [];
+    for (const pk of p2ms.pubkeys) {
+        const matched = partialSig.filter((ps) => {
+            return equals(ps.pubkey, pk);
+        })[0];
+        if (matched) {
+            result.push(new Uint8Array(matched.signature));
+        }
+    }
+    return result;
+}