@btc-vision/bitcoin 6.5.6 → 7.0.0-alpha.0

package/src/psbt/utils.ts

@@ -0,0 +1,188 @@
+/**
+ * PSBT utility functions
+ * @packageDocumentation
+ */
+
+import { varuint } from '../io/index.js';
+import * as bscript from '../script.js';
+import { Transaction } from '../transaction.js';
+import { isP2MS, isP2PK, isP2PKH, isP2SHScript, isP2WPKH, isP2WSHScript } from './psbtutils.js';
+import type { ScriptType } from './types.js';
+import type { Script } from '../types.js';
+import { checkRedeemScript, checkWitnessScript } from './validation.js';
+
+/**
+ * Converts a witness script buffer to an array of witness stack items.
+ * @param buffer - The witness script buffer
+ * @returns Array of witness stack items
+ */
+export function scriptWitnessToWitnessStack(buffer: Uint8Array): Uint8Array[] {
+    let offset = 0;
+
+    function readSlice(n: number): Uint8Array {
+        offset += n;
+        return buffer.subarray(offset - n, offset);
+    }
+
+    function readVarInt(): number {
+        const vi = varuint.decode(buffer, offset);
+        offset += vi.bytes;
+        return vi.numberValue || 0;
+    }
+
+    function readVarSlice(): Uint8Array {
+        return readSlice(readVarInt());
+    }
+
+    function readVector(): Uint8Array[] {
+        const count = readVarInt();
+        const vector: Uint8Array[] = [];
+        for (let i = 0; i < count; i++) vector.push(readVarSlice());
+        return vector;
+    }
+
+    return readVector();
+}
+
+/**
+ * Converts a sighash type to a human-readable string.
+ * @param sighashType - The sighash type value
+ * @returns Human-readable sighash type string
+ */
+export function sighashTypeToString(sighashType: number): string {
+    let text = sighashType & Transaction.SIGHASH_ANYONECANPAY ? 'SIGHASH_ANYONECANPAY | ' : '';
+    const sigMod = sighashType & 0x1f;
+    switch (sigMod) {
+        case Transaction.SIGHASH_ALL:
+            text += 'SIGHASH_ALL';
+            break;
+        case Transaction.SIGHASH_SINGLE:
+            text += 'SIGHASH_SINGLE';
+            break;
+        case Transaction.SIGHASH_NONE:
+            text += 'SIGHASH_NONE';
+            break;
+    }
+    return text;
+}
+
+/**
+ * Compresses an uncompressed public key to compressed form.
+ * @param pubkey - The public key (33 or 65 bytes)
+ * @returns Compressed public key (33 bytes)
+ */
+export function compressPubkey(pubkey: Uint8Array): Uint8Array {
+    if (pubkey.length === 65) {
+        const parity = pubkey[64]! & 1;
+        const newKey = new Uint8Array(pubkey.subarray(0, 33));
+        newKey[0] = 2 | parity;
+        return newKey;
+    }
+    return new Uint8Array(pubkey);
+}
+
+/**
+ * Checks if a buffer looks like a public key.
+ * @param buf - The buffer to check
+ * @returns True if the buffer is a valid compressed public key format
+ */
+export function isPubkeyLike(buf: Uint8Array): boolean {
+    return buf.length === 33 && bscript.isCanonicalPubKey(buf);
+}
+
+/**
+ * Checks if a buffer looks like a signature.
+ * @param buf - The buffer to check
+ * @returns True if the buffer is a valid canonical signature format
+ */
+export function isSigLike(buf: Uint8Array): boolean {
+    return bscript.isCanonicalScriptSignature(buf);
+}
+
+/**
+ * Classifies a script into a known script type.
+ * @param script - The script to classify
+ * @returns The script type
+ */
+export function classifyScript(script: Uint8Array): ScriptType {
+    if (isP2WPKH(script)) return 'witnesspubkeyhash';
+    if (isP2PKH(script)) return 'pubkeyhash';
+    if (isP2MS(script)) return 'multisig';
+    if (isP2PK(script)) return 'pubkey';
+    return 'nonstandard';
+}
+
+/**
+ * Creates an array of numbers from 0 to n-1.
+ * @param n - The length of the array
+ * @returns Array of numbers [0, 1, 2, ..., n-1]
+ */
+export function range(n: number): number[] {
+    return [...Array(n).keys()];
+}
+
+/**
+ * Validates that a script is not P2WPKH or P2SH (invalid for P2WSH).
+ * @param script - The script to check
+ * @throws {Error} If the script is P2WPKH or P2SH
+ */
+export function checkInvalidP2WSH(script: Uint8Array): void {
+    if (isP2WPKH(script) || isP2SHScript(script)) {
+        throw new Error('P2WPKH or P2SH can not be contained within P2WSH');
+    }
+}
+
+/**
+ * Extracts the meaningful script from a potentially wrapped script.
+ * Handles P2SH, P2WSH, and P2SH-P2WSH wrapping.
+ * @param script - The script to analyze
+ * @param index - The input/output index (for error messages)
+ * @param ioType - Whether this is an input or output
+ * @param redeemScript - Optional redeem script for P2SH
+ * @param witnessScript - Optional witness script for P2WSH
+ * @returns The meaningful script and its type
+ */
+export function getMeaningfulScript(
+    script: Uint8Array,
+    index: number,
+    ioType: 'input' | 'output',
+    redeemScript?: Uint8Array,
+    witnessScript?: Uint8Array,
+): {
+    meaningfulScript: Uint8Array;
+    type: 'p2sh' | 'p2wsh' | 'p2sh-p2wsh' | 'raw';
+} {
+    const isP2SH = isP2SHScript(script);
+    const isP2SHP2WSH = isP2SH && redeemScript && isP2WSHScript(redeemScript);
+    const isP2WSH = isP2WSHScript(script);
+
+    if (isP2SH && redeemScript === undefined)
+        throw new Error('scriptPubkey is P2SH but redeemScript missing');
+    let meaningfulScript: Uint8Array;
+
+    if (isP2SHP2WSH) {
+        if (!witnessScript)
+            throw new Error('scriptPubkey or redeemScript is P2WSH but witnessScript missing');
+        if (!redeemScript) throw new Error('P2SH-P2WSH requires redeemScript');
+        meaningfulScript = witnessScript;
+        checkRedeemScript(index, script as Script, redeemScript as Script, ioType);
+        checkWitnessScript(index, redeemScript as Script, witnessScript as Script, ioType);
+        checkInvalidP2WSH(meaningfulScript);
+    } else if (isP2WSH) {
+        if (!witnessScript)
+            throw new Error('scriptPubkey or redeemScript is P2WSH but witnessScript missing');
+        meaningfulScript = witnessScript;
+        checkWitnessScript(index, script as Script, witnessScript as Script, ioType);
+        checkInvalidP2WSH(meaningfulScript);
+    } else if (isP2SH) {
+        if (!redeemScript) throw new Error('P2SH requires redeemScript');
+        meaningfulScript = redeemScript;
+        checkRedeemScript(index, script as Script, redeemScript as Script, ioType);
+    } else {
+        meaningfulScript = script;
+    }
+    return {
+        meaningfulScript,
+        type: isP2SHP2WSH ? 'p2sh-p2wsh' : isP2SH ? 'p2sh' : isP2WSH ? 'p2wsh' : 'raw',
+    };
+}

package/src/psbt/validation.ts

@@ -0,0 +1,192 @@
+/**
+ * PSBT validation utilities
+ * @packageDocumentation
+ */
+
+import type { PsbtInput } from 'bip174';
+import { reverse, equals, toHex } from '../io/index.js';
+import * as payments from '../payments/index.js';
+import type { P2SHPayment, Payment, PaymentOpts } from '../payments/index.js';
+import { checkTaprootInputForSigs, isTaprootInput } from './bip371.js';
+import { checkInputForSig, pubkeyInScript } from './psbtutils.js';
+import * as bscript from '../script.js';
+import type { Transaction } from '../transaction.js';
+import type { PsbtCache } from './types.js';
+import type { PublicKey, Script } from '../types.js';
+
+/**
+ * Validates that a number is a valid 32-bit unsigned integer.
+ * @param num - The number to validate
+ * @throws {Error} If the number is not a valid 32-bit integer
+ */
+export function check32Bit(num: number): void {
+    if (typeof num !== 'number' || num !== Math.floor(num) || num > 0xffffffff || num < 0) {
+        throw new Error('Invalid 32 bit integer');
+    }
+}
+
+/**
+ * Checks if the cache is in a valid state for export.
+ * @param cache - The PSBT cache to check
+ * @throws {Error} If the cache is not BIP174 compliant
+ */
+export function checkCache(cache: PsbtCache): void {
+    if (cache.unsafeSignNonSegwit) {
+        throw new Error('Not BIP174 compliant, can not export');
+    }
+}
+
+/**
+ * Checks if a PSBT input has been finalized.
+ * @param input - The PSBT input to check
+ * @returns True if the input has finalScriptSig or finalScriptWitness
+ */
+export function isFinalized(input: PsbtInput): boolean {
+    return !!input.finalScriptSig || !!input.finalScriptWitness;
+}
+
+/**
+ * Validates that a transaction has empty scriptSigs and witnesses.
+ * @param tx - The transaction to check
+ * @throws {Error} If any input has non-empty scripts
+ */
+export function checkTxEmpty(tx: Transaction): void {
+    const isEmpty = tx.ins.every(
+        (input) =>
+            input.script &&
+            input.script.length === 0 &&
+            input.witness &&
+            input.witness.length === 0,
+    );
+    if (!isEmpty) {
+        throw new Error('Format Error: Transaction ScriptSigs are not empty');
+    }
+}
+
+/**
+ * Checks and caches a transaction input to detect duplicates.
+ * @param cache - The PSBT cache
+ * @param input - The input to check
+ * @throws {Error} If a duplicate input is detected
+ */
+export function checkTxInputCache(
+    cache: PsbtCache,
+    input: { hash: Uint8Array; index: number },
+): void {
+    const reversed = reverse(new Uint8Array(input.hash));
+    const key = `${toHex(reversed)}:${input.index}`;
+    if (cache.txInCache[key]) throw new Error('Duplicate input detected.');
+    (cache.txInCache as Record<string, number>)[key] = 1;
+}
+
+/**
+ * Checks all transaction inputs for duplicates.
+ * @param tx - The transaction to check
+ * @param cache - The PSBT cache
+ * @throws {Error} If duplicate inputs are detected
+ */
+export function checkTxForDupeIns(tx: Transaction, cache: PsbtCache): void {
+    tx.ins.forEach((input) => {
+        checkTxInputCache(cache, input);
+    });
+}
+
+/**
+ * Checks if any inputs have partial signatures that would prevent modification.
+ * @param inputs - The PSBT inputs to check
+ * @param action - The action being attempted (for error message)
+ * @param hasSignaturesCache - Optional cached flag (true = definitely has sigs, false = check needed)
+ * @throws {Error} If signatures exist and prevent modification
+ */
+export function checkInputsForPartialSig(
+    inputs: PsbtInput[],
+    action: string,
+    hasSignaturesCache?: boolean,
+): void {
+    // Fast path: if cache says no signatures, skip entirely (O(1))
+    if (hasSignaturesCache === false) {
+        return;
+    }
+
+    // Only do full validation if signatures might exist
+    inputs.forEach((input) => {
+        const throws = isTaprootInput(input)
+            ? checkTaprootInputForSigs(input, action)
+            : checkInputForSig(input, action);
+        if (throws) throw new Error('Can not modify transaction, signatures exist.');
+    });
+}
+
+/**
+ * Validates that partial signature sighash types match the input's sighash type.
+ * @param input - The PSBT input to check
+ * @throws {Error} If sighash types don't match
+ */
+export function checkPartialSigSighashes(input: PsbtInput): void {
+    if (!input.sighashType || !input.partialSig) return;
+    const { partialSig, sighashType } = input;
+    partialSig.forEach((pSig) => {
+        const { hashType } = bscript.signature.decode(pSig.signature);
+        if (sighashType !== hashType) {
+            throw new Error('Signature sighash does not match input sighash type');
+        }
+    });
+}
+
+/**
+ * Validates that a pubkey exists in a script.
+ * @param pubkey - The pubkey to find
+ * @param script - The script to search
+ * @param action - The action being attempted (for error message)
+ * @throws {Error} If the pubkey is not found in the script
+ */
+export function checkScriptForPubkey(pubkey: PublicKey, script: Script, action: string): void {
+    if (!pubkeyInScript(pubkey, script)) {
+        throw new Error(
+            `Can not ${action} for this input with the key ${toHex(pubkey)}`,
+        );
+    }
+}
+
+/**
+ * Creates a script checker function for validating redeem/witness scripts.
+ * @param payment - The payment function to use (p2sh or p2wsh)
+ * @param paymentScriptName - Name for error messages
+ * @returns A function that validates scripts match
+ */
+export function scriptCheckerFactory(
+    payment: (a: Omit<Payment, 'name'>, opts?: PaymentOpts) => Payment,
+    paymentScriptName: string,
+): (
+    idx: number,
+    scriptPubKey: Script,
+    redeemScript: Script,
+    ioType: 'input' | 'output',
+) => void {
+    return (
+        inputIndex: number,
+        scriptPubKey: Script,
+        redeemScript: Script,
+        ioType: 'input' | 'output',
+    ): void => {
+        const redeemScriptOutput = payment({
+            redeem: { output: redeemScript },
+        } as P2SHPayment).output as Uint8Array;
+
+        if (!equals(scriptPubKey, redeemScriptOutput)) {
+            throw new Error(
+                `${paymentScriptName} for ${ioType} #${inputIndex} doesn't match the scriptPubKey in the prevout`,
+            );
+        }
+    };
+}
+
+/**
+ * Validates that a redeem script matches the scriptPubKey.
+ */
+export const checkRedeemScript = scriptCheckerFactory(payments.p2sh, 'Redeem script');
+
+/**
+ * Validates that a witness script matches the scriptPubKey.
+ */
+export const checkWitnessScript = scriptCheckerFactory(payments.p2wsh, 'Witness script');