@btc-vision/bitcoin 6.3.0

package/src/psbt/bip371.js

@@ -0,0 +1,424 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getTapKeySigFromWithness =
+    exports.checkTaprootInputForSigs =
+    exports.tapTreeFromList =
+    exports.tapTreeToList =
+    exports.tweakInternalPubKey =
+    exports.checkTaprootOutputFields =
+    exports.checkTaprootInputFields =
+    exports.isTaprootOutput =
+    exports.isTaprootInput =
+    exports.serializeTaprootSignature =
+    exports.tapScriptFinalizer =
+    exports.toXOnly =
+        void 0;
+const types_1 = require('../types');
+const transaction_1 = require('../transaction');
+const psbtutils_1 = require('./psbtutils');
+const bip341_1 = require('../payments/bip341');
+const payments_1 = require('../payments');
+const toXOnly = pubKey => (pubKey.length === 32 ? pubKey : pubKey.slice(1, 33));
+exports.toXOnly = toXOnly;
+/**
+ * Default tapscript finalizer. It searches for the `tapLeafHashToFinalize` if provided.
+ * Otherwise it will search for the tapleaf that has at least one signature and has the shortest path.
+ * @param inputIndex the position of the PSBT input.
+ * @param input the PSBT input.
+ * @param tapLeafHashToFinalize optional, if provided the finalizer will search for a tapleaf that has this hash
+ *                              and will try to build the finalScriptWitness.
+ * @returns the finalScriptWitness or throws an exception if no tapleaf found.
+ */
+function tapScriptFinalizer(inputIndex, input, tapLeafHashToFinalize) {
+    const tapLeaf = findTapLeafToFinalize(
+        input,
+        inputIndex,
+        tapLeafHashToFinalize,
+    );
+    try {
+        const sigs = sortSignatures(input, tapLeaf);
+        const witness = sigs
+            .concat(tapLeaf.script)
+            .concat(tapLeaf.controlBlock);
+        return {
+            finalScriptWitness: (0, psbtutils_1.witnessStackToScriptWitness)(
+                witness,
+            ),
+        };
+    } catch (err) {
+        throw new Error(
+            `Can not finalize taproot input #${inputIndex}: ${err}`,
+        );
+    }
+}
+exports.tapScriptFinalizer = tapScriptFinalizer;
+function serializeTaprootSignature(sig, sighashType) {
+    const sighashTypeByte = sighashType
+        ? Buffer.from([sighashType])
+        : Buffer.from([]);
+    return Buffer.concat([sig, sighashTypeByte]);
+}
+exports.serializeTaprootSignature = serializeTaprootSignature;
+function isTaprootInput(input) {
+    return (
+        input &&
+        !!(
+            input.tapInternalKey ||
+            input.tapMerkleRoot ||
+            (input.tapLeafScript && input.tapLeafScript.length) ||
+            (input.tapBip32Derivation && input.tapBip32Derivation.length) ||
+            (input.witnessUtxo &&
+                (0, psbtutils_1.isP2TR)(input.witnessUtxo.script))
+        )
+    );
+}
+exports.isTaprootInput = isTaprootInput;
+function isTaprootOutput(output, script) {
+    return (
+        output &&
+        !!(
+            output.tapInternalKey ||
+            output.tapTree ||
+            (output.tapBip32Derivation && output.tapBip32Derivation.length) ||
+            (script && (0, psbtutils_1.isP2TR)(script))
+        )
+    );
+}
+exports.isTaprootOutput = isTaprootOutput;
+function checkTaprootInputFields(inputData, newInputData, action) {
+    checkMixedTaprootAndNonTaprootInputFields(inputData, newInputData, action);
+    checkIfTapLeafInTree(inputData, newInputData, action);
+}
+exports.checkTaprootInputFields = checkTaprootInputFields;
+function checkTaprootOutputFields(outputData, newOutputData, action) {
+    checkMixedTaprootAndNonTaprootOutputFields(
+        outputData,
+        newOutputData,
+        action,
+    );
+    checkTaprootScriptPubkey(outputData, newOutputData);
+}
+exports.checkTaprootOutputFields = checkTaprootOutputFields;
+function checkTaprootScriptPubkey(outputData, newOutputData) {
+    if (!newOutputData.tapTree && !newOutputData.tapInternalKey) return;
+    const tapInternalKey =
+        newOutputData.tapInternalKey || outputData.tapInternalKey;
+    const tapTree = newOutputData.tapTree || outputData.tapTree;
+    if (tapInternalKey) {
+        const { script: scriptPubkey } = outputData;
+        const script = getTaprootScripPubkey(tapInternalKey, tapTree);
+        if (scriptPubkey && !scriptPubkey.equals(script))
+            throw new Error(
+                'Error adding output. Script or address missmatch.',
+            );
+    }
+}
+function getTaprootScripPubkey(tapInternalKey, tapTree) {
+    const scriptTree = tapTree && tapTreeFromList(tapTree.leaves);
+    const { output } = (0, payments_1.p2tr)({
+        internalPubkey: tapInternalKey,
+        scriptTree,
+    });
+    return output;
+}
+function tweakInternalPubKey(inputIndex, input) {
+    const tapInternalKey = input.tapInternalKey;
+    const outputKey =
+        tapInternalKey &&
+        (0, bip341_1.tweakKey)(tapInternalKey, input.tapMerkleRoot);
+    if (!outputKey)
+        throw new Error(
+            `Cannot tweak tap internal key for input #${inputIndex}. Public key: ${
+                tapInternalKey && tapInternalKey.toString('hex')
+            }`,
+        );
+    return outputKey.x;
+}
+exports.tweakInternalPubKey = tweakInternalPubKey;
+/**
+ * Convert a binary tree to a BIP371 type list. Each element of the list is (according to BIP371):
+ * One or more tuples representing the depth, leaf version, and script for a leaf in the Taproot tree,
+ * allowing the entire tree to be reconstructed. The tuples must be in depth first search order so that
+ * the tree is correctly reconstructed.
+ * @param tree the binary tap tree
+ * @returns a list of BIP 371 tapleaves
+ */
+function tapTreeToList(tree) {
+    if (!(0, types_1.isTaptree)(tree))
+        throw new Error(
+            'Cannot convert taptree to tapleaf list. Expecting a tapree structure.',
+        );
+    return _tapTreeToList(tree);
+}
+exports.tapTreeToList = tapTreeToList;
+/**
+ * Convert a BIP371 TapLeaf list to a TapTree (binary).
+ * @param leaves a list of tapleaves where each element of the list is (according to BIP371):
+ * One or more tuples representing the depth, leaf version, and script for a leaf in the Taproot tree,
+ * allowing the entire tree to be reconstructed. The tuples must be in depth first search order so that
+ * the tree is correctly reconstructed.
+ * @returns the corresponding taptree, or throws an exception if the tree cannot be reconstructed
+ */
+function tapTreeFromList(leaves = []) {
+    if (leaves.length === 1 && leaves[0].depth === 0)
+        return {
+            output: leaves[0].script,
+            version: leaves[0].leafVersion,
+        };
+    return instertLeavesInTree(leaves);
+}
+exports.tapTreeFromList = tapTreeFromList;
+function checkTaprootInputForSigs(input, action) {
+    const sigs = extractTaprootSigs(input);
+    return sigs.some(sig =>
+        (0, psbtutils_1.signatureBlocksAction)(
+            sig,
+            decodeSchnorrSignature,
+            action,
+        ),
+    );
+}
+exports.checkTaprootInputForSigs = checkTaprootInputForSigs;
+function decodeSchnorrSignature(signature) {
+    return {
+        signature: signature.slice(0, 64),
+        hashType:
+            signature.slice(64)[0] || transaction_1.Transaction.SIGHASH_DEFAULT,
+    };
+}
+function extractTaprootSigs(input) {
+    const sigs = [];
+    if (input.tapKeySig) sigs.push(input.tapKeySig);
+    if (input.tapScriptSig)
+        sigs.push(...input.tapScriptSig.map(s => s.signature));
+    if (!sigs.length) {
+        const finalTapKeySig = getTapKeySigFromWithness(
+            input.finalScriptWitness,
+        );
+        if (finalTapKeySig) sigs.push(finalTapKeySig);
+    }
+    return sigs;
+}
+function getTapKeySigFromWithness(finalScriptWitness) {
+    if (!finalScriptWitness) return;
+    const witness = finalScriptWitness.slice(2);
+    // todo: add schnorr signature validation
+    if (witness.length === 64 || witness.length === 65) return witness;
+}
+exports.getTapKeySigFromWithness = getTapKeySigFromWithness;
+function _tapTreeToList(tree, leaves = [], depth = 0) {
+    if (depth > bip341_1.MAX_TAPTREE_DEPTH)
+        throw new Error('Max taptree depth exceeded.');
+    if (!tree) return [];
+    if ((0, types_1.isTapleaf)(tree)) {
+        leaves.push({
+            depth,
+            leafVersion: tree.version || bip341_1.LEAF_VERSION_TAPSCRIPT,
+            script: tree.output,
+        });
+        return leaves;
+    }
+    if (tree[0]) _tapTreeToList(tree[0], leaves, depth + 1);
+    if (tree[1]) _tapTreeToList(tree[1], leaves, depth + 1);
+    return leaves;
+}
+function instertLeavesInTree(leaves) {
+    let tree;
+    for (const leaf of leaves) {
+        tree = instertLeafInTree(leaf, tree);
+        if (!tree) throw new Error(`No room left to insert tapleaf in tree`);
+    }
+    return tree;
+}
+function instertLeafInTree(leaf, tree, depth = 0) {
+    if (depth > bip341_1.MAX_TAPTREE_DEPTH)
+        throw new Error('Max taptree depth exceeded.');
+    if (leaf.depth === depth) {
+        if (!tree)
+            return {
+                output: leaf.script,
+                version: leaf.leafVersion,
+            };
+        return;
+    }
+    if ((0, types_1.isTapleaf)(tree)) return;
+    const leftSide = instertLeafInTree(leaf, tree && tree[0], depth + 1);
+    if (leftSide) return [leftSide, tree && tree[1]];
+    const rightSide = instertLeafInTree(leaf, tree && tree[1], depth + 1);
+    if (rightSide) return [tree && tree[0], rightSide];
+}
+function checkMixedTaprootAndNonTaprootInputFields(
+    inputData,
+    newInputData,
+    action,
+) {
+    const isBadTaprootUpdate =
+        isTaprootInput(inputData) && hasNonTaprootFields(newInputData);
+    const isBadNonTaprootUpdate =
+        hasNonTaprootFields(inputData) && isTaprootInput(newInputData);
+    const hasMixedFields =
+        inputData === newInputData &&
+        isTaprootInput(newInputData) &&
+        hasNonTaprootFields(newInputData); // todo: bad? use !===
+    if (isBadTaprootUpdate || isBadNonTaprootUpdate || hasMixedFields)
+        throw new Error(
+            `Invalid arguments for Psbt.${action}. ` +
+                `Cannot use both taproot and non-taproot fields.`,
+        );
+}
+function checkMixedTaprootAndNonTaprootOutputFields(
+    inputData,
+    newInputData,
+    action,
+) {
+    const isBadTaprootUpdate =
+        isTaprootOutput(inputData) && hasNonTaprootFields(newInputData);
+    const isBadNonTaprootUpdate =
+        hasNonTaprootFields(inputData) && isTaprootOutput(newInputData);
+    const hasMixedFields =
+        inputData === newInputData &&
+        isTaprootOutput(newInputData) &&
+        hasNonTaprootFields(newInputData);
+    if (isBadTaprootUpdate || isBadNonTaprootUpdate || hasMixedFields)
+        throw new Error(
+            `Invalid arguments for Psbt.${action}. ` +
+                `Cannot use both taproot and non-taproot fields.`,
+        );
+}
+/**
+ * Checks if the tap leaf is part of the tap tree for the given input data.
+ * Throws an error if the tap leaf is not part of the tap tree.
+ * @param inputData - The original PsbtInput data.
+ * @param newInputData - The new PsbtInput data.
+ * @param action - The action being performed.
+ * @throws {Error} - If the tap leaf is not part of the tap tree.
+ */
+function checkIfTapLeafInTree(inputData, newInputData, action) {
+    if (newInputData.tapMerkleRoot) {
+        const newLeafsInTree = (newInputData.tapLeafScript || []).every(l =>
+            isTapLeafInTree(l, newInputData.tapMerkleRoot),
+        );
+        const oldLeafsInTree = (inputData.tapLeafScript || []).every(l =>
+            isTapLeafInTree(l, newInputData.tapMerkleRoot),
+        );
+        if (!newLeafsInTree || !oldLeafsInTree)
+            throw new Error(
+                `Invalid arguments for Psbt.${action}. Tapleaf not part of taptree.`,
+            );
+    } else if (inputData.tapMerkleRoot) {
+        const newLeafsInTree = (newInputData.tapLeafScript || []).every(l =>
+            isTapLeafInTree(l, inputData.tapMerkleRoot),
+        );
+        if (!newLeafsInTree)
+            throw new Error(
+                `Invalid arguments for Psbt.${action}. Tapleaf not part of taptree.`,
+            );
+    }
+}
+/**
+ * Checks if a TapLeafScript is present in a Merkle tree.
+ * @param tapLeaf The TapLeafScript to check.
+ * @param merkleRoot The Merkle root of the tree. If not provided, the function assumes the TapLeafScript is present.
+ * @returns A boolean indicating whether the TapLeafScript is present in the tree.
+ */
+function isTapLeafInTree(tapLeaf, merkleRoot) {
+    if (!merkleRoot) return true;
+    const leafHash = (0, bip341_1.tapleafHash)({
+        output: tapLeaf.script,
+        version: tapLeaf.leafVersion,
+    });
+    const rootHash = (0, bip341_1.rootHashFromPath)(
+        tapLeaf.controlBlock,
+        leafHash,
+    );
+    return rootHash.equals(merkleRoot);
+}
+/**
+ * Sorts the signatures in the input's tapScriptSig array based on their position in the tapLeaf script.
+ *
+ * @param input - The PsbtInput object.
+ * @param tapLeaf - The TapLeafScript object.
+ * @returns An array of sorted signatures as Buffers.
+ */
+function sortSignatures(input, tapLeaf) {
+    const leafHash = (0, bip341_1.tapleafHash)({
+        output: tapLeaf.script,
+        version: tapLeaf.leafVersion,
+    });
+    return (input.tapScriptSig || [])
+        .filter(tss => tss.leafHash.equals(leafHash))
+        .map(tss => addPubkeyPositionInScript(tapLeaf.script, tss))
+        .sort((t1, t2) => t2.positionInScript - t1.positionInScript)
+        .map(t => t.signature);
+}
+/**
+ * Adds the position of a public key in a script to a TapScriptSig object.
+ * @param script The script in which to find the position of the public key.
+ * @param tss The TapScriptSig object to add the position to.
+ * @returns A TapScriptSigWitPosition object with the added position.
+ */
+function addPubkeyPositionInScript(script, tss) {
+    return Object.assign(
+        {
+            positionInScript: (0, psbtutils_1.pubkeyPositionInScript)(
+                tss.pubkey,
+                script,
+            ),
+        },
+        tss,
+    );
+}
+/**
+ * Find tapleaf by hash, or get the signed tapleaf with the shortest path.
+ */
+function findTapLeafToFinalize(input, inputIndex, leafHashToFinalize) {
+    if (!input.tapScriptSig || !input.tapScriptSig.length)
+        throw new Error(
+            `Can not finalize taproot input #${inputIndex}. No tapleaf script signature provided.`,
+        );
+    const tapLeaf = (input.tapLeafScript || [])
+        .sort((a, b) => a.controlBlock.length - b.controlBlock.length)
+        .find(leaf =>
+            canFinalizeLeaf(leaf, input.tapScriptSig, leafHashToFinalize),
+        );
+    if (!tapLeaf)
+        throw new Error(
+            `Can not finalize taproot input #${inputIndex}. Signature for tapleaf script not found.`,
+        );
+    return tapLeaf;
+}
+/**
+ * Determines whether a TapLeafScript can be finalized.
+ *
+ * @param leaf - The TapLeafScript to check.
+ * @param tapScriptSig - The array of TapScriptSig objects.
+ * @param hash - The optional hash to compare with the leaf hash.
+ * @returns A boolean indicating whether the TapLeafScript can be finalized.
+ */
+function canFinalizeLeaf(leaf, tapScriptSig, hash) {
+    const leafHash = (0, bip341_1.tapleafHash)({
+        output: leaf.script,
+        version: leaf.leafVersion,
+    });
+    const whiteListedHash = !hash || hash.equals(leafHash);
+    return (
+        whiteListedHash &&
+        tapScriptSig.find(tss => tss.leafHash.equals(leafHash)) !== undefined
+    );
+}
+/**
+ * Checks if the given PsbtInput or PsbtOutput has non-taproot fields.
+ * Non-taproot fields include redeemScript, witnessScript, and bip32Derivation.
+ * @param io The PsbtInput or PsbtOutput to check.
+ * @returns A boolean indicating whether the given input or output has non-taproot fields.
+ */
+function hasNonTaprootFields(io) {
+    return (
+        io &&
+        !!(
+            io.redeemScript ||
+            io.witnessScript ||
+            (io.bip32Derivation && io.bip32Derivation.length)
+        )
+    );
+}

package/src/psbt/psbtutils.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { PartialSig, PsbtInput } from 'bip174/src/lib/interfaces';
+export declare const isP2MS: (script: Buffer) => boolean;
+export declare const isP2PK: (script: Buffer) => boolean;
+export declare const isP2PKH: (script: Buffer) => boolean;
+export declare const isP2WPKH: (script: Buffer) => boolean;
+export declare const isP2WSHScript: (script: Buffer) => boolean;
+export declare const isP2SHScript: (script: Buffer) => boolean;
+export declare const isP2TR: (script: Buffer) => boolean;
+/**
+ * Converts a witness stack to a script witness.
+ * @param witness The witness stack to convert.
+ * @returns The script witness as a Buffer.
+ */
+/**
+ * Converts a witness stack to a script witness.
+ * @param witness The witness stack to convert.
+ * @returns The converted script witness.
+ */
+export declare function witnessStackToScriptWitness(witness: Buffer[]): Buffer;
+/**
+ * Finds the position of a public key in a script.
+ * @param pubkey The public key to search for.
+ * @param script The script to search in.
+ * @returns The index of the public key in the script, or -1 if not found.
+ * @throws {Error} If there is an unknown script error.
+ */
+export declare function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number;
+/**
+ * Checks if a public key is present in a script.
+ * @param pubkey The public key to check.
+ * @param script The script to search in.
+ * @returns A boolean indicating whether the public key is present in the script.
+ */
+export declare function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean;
+/**
+ * Checks if an input contains a signature for a specific action.
+ * @param input - The input to check.
+ * @param action - The action to check for.
+ * @returns A boolean indicating whether the input contains a signature for the specified action.
+ */
+export declare function checkInputForSig(input: PsbtInput, action: string): boolean;
+type SignatureDecodeFunc = (buffer: Buffer) => {
+    signature: Buffer;
+    hashType: number;
+};
+/**
+ * Determines if a given action is allowed for a signature block.
+ * @param signature - The signature block.
+ * @param signatureDecodeFn - The function used to decode the signature.
+ * @param action - The action to be checked.
+ * @returns True if the action is allowed, false otherwise.
+ */
+export declare function signatureBlocksAction(signature: Buffer, signatureDecodeFn: SignatureDecodeFunc, action: string): boolean;
+/**
+ * Retrieves the partial signatures (Psigs) from the input's final scripts.
+ * Psigs are extracted from both the final scriptSig and final scriptWitness of the input.
+ * Only canonical script signatures are considered.
+ *
+ * @param input - The PsbtInput object representing the input.
+ * @returns An array of PartialSig objects containing the extracted Psigs.
+ */
+export declare function getPsigsFromInputFinalScripts(input: PsbtInput): PartialSig[];
+export {};

package/src/psbt/psbtutils.js

@@ -0,0 +1,191 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getPsigsFromInputFinalScripts =
+    exports.signatureBlocksAction =
+    exports.checkInputForSig =
+    exports.pubkeyInScript =
+    exports.pubkeyPositionInScript =
+    exports.witnessStackToScriptWitness =
+    exports.isP2TR =
+    exports.isP2SHScript =
+    exports.isP2WSHScript =
+    exports.isP2WPKH =
+    exports.isP2PKH =
+    exports.isP2PK =
+    exports.isP2MS =
+        void 0;
+const varuint = require('bip174/src/lib/converter/varint');
+const bscript = require('../script');
+const transaction_1 = require('../transaction');
+const crypto_1 = require('../crypto');
+const payments = require('../payments');
+function isPaymentFactory(payment) {
+    return script => {
+        try {
+            payment({ output: script });
+            return true;
+        } catch (err) {
+            return false;
+        }
+    };
+}
+exports.isP2MS = isPaymentFactory(payments.p2ms);
+exports.isP2PK = isPaymentFactory(payments.p2pk);
+exports.isP2PKH = isPaymentFactory(payments.p2pkh);
+exports.isP2WPKH = isPaymentFactory(payments.p2wpkh);
+exports.isP2WSHScript = isPaymentFactory(payments.p2wsh);
+exports.isP2SHScript = isPaymentFactory(payments.p2sh);
+exports.isP2TR = isPaymentFactory(payments.p2tr);
+/**
+ * Converts a witness stack to a script witness.
+ * @param witness The witness stack to convert.
+ * @returns The script witness as a Buffer.
+ */
+/**
+ * Converts a witness stack to a script witness.
+ * @param witness The witness stack to convert.
+ * @returns The converted script witness.
+ */
+function witnessStackToScriptWitness(witness) {
+    let buffer = Buffer.allocUnsafe(0);
+    function writeSlice(slice) {
+        buffer = Buffer.concat([buffer, Buffer.from(slice)]);
+    }
+    function writeVarInt(i) {
+        const currentLen = buffer.length;
+        const varintLen = varuint.encodingLength(i);
+        buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
+        varuint.encode(i, buffer, currentLen);
+    }
+    function writeVarSlice(slice) {
+        writeVarInt(slice.length);
+        writeSlice(slice);
+    }
+    function writeVector(vector) {
+        writeVarInt(vector.length);
+        vector.forEach(writeVarSlice);
+    }
+    writeVector(witness);
+    return buffer;
+}
+exports.witnessStackToScriptWitness = witnessStackToScriptWitness;
+/**
+ * Finds the position of a public key in a script.
+ * @param pubkey The public key to search for.
+ * @param script The script to search in.
+ * @returns The index of the public key in the script, or -1 if not found.
+ * @throws {Error} If there is an unknown script error.
+ */
+function pubkeyPositionInScript(pubkey, script) {
+    const pubkeyHash = (0, crypto_1.hash160)(pubkey);
+    const pubkeyXOnly = pubkey.slice(1, 33); // slice before calling?
+    const decompiled = bscript.decompile(script);
+    if (decompiled === null) throw new Error('Unknown script error');
+    return decompiled.findIndex(element => {
+        if (typeof element === 'number') return false;
+        return (
+            element.equals(pubkey) ||
+            element.equals(pubkeyHash) ||
+            element.equals(pubkeyXOnly)
+        );
+    });
+}
+exports.pubkeyPositionInScript = pubkeyPositionInScript;
+/**
+ * Checks if a public key is present in a script.
+ * @param pubkey The public key to check.
+ * @param script The script to search in.
+ * @returns A boolean indicating whether the public key is present in the script.
+ */
+function pubkeyInScript(pubkey, script) {
+    return pubkeyPositionInScript(pubkey, script) !== -1;
+}
+exports.pubkeyInScript = pubkeyInScript;
+/**
+ * Checks if an input contains a signature for a specific action.
+ * @param input - The input to check.
+ * @param action - The action to check for.
+ * @returns A boolean indicating whether the input contains a signature for the specified action.
+ */
+function checkInputForSig(input, action) {
+    const pSigs = extractPartialSigs(input);
+    return pSigs.some(pSig =>
+        signatureBlocksAction(pSig, bscript.signature.decode, action),
+    );
+}
+exports.checkInputForSig = checkInputForSig;
+/**
+ * Determines if a given action is allowed for a signature block.
+ * @param signature - The signature block.
+ * @param signatureDecodeFn - The function used to decode the signature.
+ * @param action - The action to be checked.
+ * @returns True if the action is allowed, false otherwise.
+ */
+function signatureBlocksAction(signature, signatureDecodeFn, action) {
+    const { hashType } = signatureDecodeFn(signature);
+    const whitelist = [];
+    const isAnyoneCanPay =
+        hashType & transaction_1.Transaction.SIGHASH_ANYONECANPAY;
+    if (isAnyoneCanPay) whitelist.push('addInput');
+    const hashMod = hashType & 0x1f;
+    switch (hashMod) {
+        case transaction_1.Transaction.SIGHASH_ALL:
+            break;
+        case transaction_1.Transaction.SIGHASH_SINGLE:
+        case transaction_1.Transaction.SIGHASH_NONE:
+            whitelist.push('addOutput');
+            whitelist.push('setInputSequence');
+            break;
+    }
+    if (whitelist.indexOf(action) === -1) {
+        return true;
+    }
+    return false;
+}
+exports.signatureBlocksAction = signatureBlocksAction;
+/**
+ * Extracts the signatures from a PsbtInput object.
+ * If the input has partial signatures, it returns an array of the signatures.
+ * If the input does not have partial signatures, it checks if it has a finalScriptSig or finalScriptWitness.
+ * If it does, it extracts the signatures from the final scripts and returns them.
+ * If none of the above conditions are met, it returns an empty array.
+ *
+ * @param input - The PsbtInput object from which to extract the signatures.
+ * @returns An array of signatures extracted from the PsbtInput object.
+ */
+function extractPartialSigs(input) {
+    let pSigs = [];
+    if ((input.partialSig || []).length === 0) {
+        if (!input.finalScriptSig && !input.finalScriptWitness) return [];
+        pSigs = getPsigsFromInputFinalScripts(input);
+    } else {
+        pSigs = input.partialSig;
+    }
+    return pSigs.map(p => p.signature);
+}
+/**
+ * Retrieves the partial signatures (Psigs) from the input's final scripts.
+ * Psigs are extracted from both the final scriptSig and final scriptWitness of the input.
+ * Only canonical script signatures are considered.
+ *
+ * @param input - The PsbtInput object representing the input.
+ * @returns An array of PartialSig objects containing the extracted Psigs.
+ */
+function getPsigsFromInputFinalScripts(input) {
+    const scriptItems = !input.finalScriptSig
+        ? []
+        : bscript.decompile(input.finalScriptSig) || [];
+    const witnessItems = !input.finalScriptWitness
+        ? []
+        : bscript.decompile(input.finalScriptWitness) || [];
+    return scriptItems
+        .concat(witnessItems)
+        .filter(item => {
+            return (
+                Buffer.isBuffer(item) &&
+                bscript.isCanonicalScriptSignature(item)
+            );
+        })
+        .map(sig => ({ signature: sig }));
+}
+exports.getPsigsFromInputFinalScripts = getPsigsFromInputFinalScripts;