@btc-vision/bitcoin 6.3.1 → 6.3.2

package/src/psbt/{bip371.js → bip371.ts}

@@ -1,25 +1,37 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.getTapKeySigFromWitness =
-    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;
+import {
+    PsbtInput,
+    PsbtOutput,
+    TapInternalKey,
+    TapLeaf,
+    TapLeafScript,
+    TapScriptSig,
+    TapTree,
+} from 'bip174/src/lib/interfaces.js';
+import { isTapleaf, isTaptree, Tapleaf, Taptree } from '../types.js';
+
+import { Transaction } from '../transaction.js';
+
+import {
+    LEAF_VERSION_TAPSCRIPT,
+    MAX_TAPTREE_DEPTH,
+    rootHashFromPath,
+    tapleafHash,
+    tweakKey,
+} from '../payments/bip341.js';
+import { p2tr } from '../payments/p2tr.js';
+import {
+    isP2TR,
+    pubkeyPositionInScript,
+    signatureBlocksAction,
+    witnessStackToScriptWitness,
+} from './psbtutils.js';
+
+export const toXOnly = (pubKey: Buffer | Uint8Array): Buffer => {
+    const buffer = pubKey.length === 32 ? pubKey : pubKey.slice(1, 33);
+
+    return Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+};
+
 /**
  * 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.
@@ -29,37 +41,31 @@ exports.toXOnly = toXOnly;
  *                              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,
-    );
+export function tapScriptFinalizer(
+    inputIndex: number,
+    input: PsbtInput,
+    tapLeafHashToFinalize?: Buffer,
+): {
+    finalScriptWitness: Buffer | undefined;
+} {
+    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,
-            ),
-        };
+        const witness = sigs.concat(tapLeaf.script).concat(tapLeaf.controlBlock);
+        return { finalScriptWitness: witnessStackToScriptWitness(witness) };
     } catch (err) {
-        throw new Error(
-            `Can not finalize taproot input #${inputIndex}: ${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([]);
+
+export function serializeTaprootSignature(sig: Buffer, sighashType?: number): Buffer {
+    const sighashTypeByte = sighashType ? Buffer.from([sighashType!]) : Buffer.from([]);
+
     return Buffer.concat([sig, sighashTypeByte]);
 }
-exports.serializeTaprootSignature = serializeTaprootSignature;
-function isTaprootInput(input) {
+
+export function isTaprootInput(input: PsbtInput): boolean {
     return (
         input &&
         !!(
@@ -67,65 +73,68 @@ function isTaprootInput(input) {
             input.tapMerkleRoot ||
             (input.tapLeafScript && input.tapLeafScript.length) ||
             (input.tapBip32Derivation && input.tapBip32Derivation.length) ||
-            (input.witnessUtxo &&
-                (0, psbtutils_1.isP2TR)(input.witnessUtxo.script))
+            (input.witnessUtxo && isP2TR(input.witnessUtxo.script))
         )
     );
 }
-exports.isTaprootInput = isTaprootInput;
-function isTaprootOutput(output, script) {
+
+export function isTaprootOutput(output: PsbtOutput, script?: Buffer): boolean {
     return (
         output &&
         !!(
             output.tapInternalKey ||
             output.tapTree ||
             (output.tapBip32Derivation && output.tapBip32Derivation.length) ||
-            (script && (0, psbtutils_1.isP2TR)(script))
+            (script && isP2TR(script))
         )
     );
 }
-exports.isTaprootOutput = isTaprootOutput;
-function checkTaprootInputFields(inputData, newInputData, action) {
+
+export function checkTaprootInputFields(
+    inputData: PsbtInput,
+    newInputData: PsbtInput,
+    action: string,
+): void {
     checkMixedTaprootAndNonTaprootInputFields(inputData, newInputData, action);
     checkIfTapLeafInTree(inputData, newInputData, action);
 }
-exports.checkTaprootInputFields = checkTaprootInputFields;
-function checkTaprootOutputFields(outputData, newOutputData, action) {
-    checkMixedTaprootAndNonTaprootOutputFields(
-        outputData,
-        newOutputData,
-        action,
-    );
+
+export function checkTaprootOutputFields(
+    outputData: PsbtOutput,
+    newOutputData: PsbtOutput,
+    action: string,
+): void {
+    checkMixedTaprootAndNonTaprootOutputFields(outputData, newOutputData, action);
     checkTaprootScriptPubkey(outputData, newOutputData);
 }
-exports.checkTaprootOutputFields = checkTaprootOutputFields;
-function checkTaprootScriptPubkey(outputData, newOutputData) {
+
+function checkTaprootScriptPubkey(outputData: PsbtOutput, newOutputData: PsbtOutput): void {
     if (!newOutputData.tapTree && !newOutputData.tapInternalKey) return;
-    const tapInternalKey =
-        newOutputData.tapInternalKey || outputData.tapInternalKey;
+
+    const tapInternalKey = newOutputData.tapInternalKey || outputData.tapInternalKey;
     const tapTree = newOutputData.tapTree || outputData.tapTree;
+
     if (tapInternalKey) {
-        const { script: scriptPubkey } = outputData;
+        const { script: scriptPubkey } = outputData as any;
         const script = getTaprootScripPubkey(tapInternalKey, tapTree);
         if (scriptPubkey && !scriptPubkey.equals(script))
-            throw new Error(
-                'Error adding output. Script or address missmatch.',
-            );
+            throw new Error('Error adding output. Script or address missmatch.');
     }
 }
-function getTaprootScripPubkey(tapInternalKey, tapTree) {
+
+function getTaprootScripPubkey(tapInternalKey: TapInternalKey, tapTree?: TapTree): Buffer {
     const scriptTree = tapTree && tapTreeFromList(tapTree.leaves);
-    const { output } = (0, payments_1.p2tr)({
+    const { output } = p2tr({
         internalPubkey: tapInternalKey,
         scriptTree,
     });
-    return output;
+    return output!;
 }
-function tweakInternalPubKey(inputIndex, input) {
+
+export function tweakInternalPubKey(inputIndex: number, input: PsbtInput): Buffer {
     const tapInternalKey = input.tapInternalKey;
-    const outputKey =
-        tapInternalKey &&
-        (0, bip341_1.tweakKey)(tapInternalKey, input.tapMerkleRoot);
+    const outputKey = tapInternalKey && tweakKey(tapInternalKey, input.tapMerkleRoot);
+
     if (!outputKey)
         throw new Error(
             `Cannot tweak tap internal key for input #${inputIndex}. Public key: ${
@@ -134,7 +143,7 @@ function tweakInternalPubKey(inputIndex, input) {
         );
     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,
@@ -143,14 +152,12 @@ exports.tweakInternalPubKey = tweakInternalPubKey;
  * @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.',
-        );
+export function tapTreeToList(tree: Taptree): TapLeaf[] {
+    if (!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):
@@ -159,61 +166,57 @@ exports.tapTreeToList = tapTreeToList;
  * the tree is correctly reconstructed.
  * @returns the corresponding taptree, or throws an exception if the tree cannot be reconstructed
  */
-function tapTreeFromList(leaves = []) {
+export function tapTreeFromList(leaves: TapLeaf[] = []): Taptree {
     if (leaves.length === 1 && leaves[0].depth === 0)
         return {
             output: leaves[0].script,
             version: leaves[0].leafVersion,
         };
+
     return insertLeavesInTree(leaves);
 }
-exports.tapTreeFromList = tapTreeFromList;
-function checkTaprootInputForSigs(input, action) {
+
+export function checkTaprootInputForSigs(input: PsbtInput, action: string): boolean {
     const sigs = extractTaprootSigs(input);
-    return sigs.some(sig =>
-        (0, psbtutils_1.signatureBlocksAction)(
-            sig,
-            decodeSchnorrSignature,
-            action,
-        ),
-    );
+    return sigs.some((sig) => signatureBlocksAction(sig, decodeSchnorrSignature, action));
 }
-exports.checkTaprootInputForSigs = checkTaprootInputForSigs;
-function decodeSchnorrSignature(signature) {
+
+function decodeSchnorrSignature(signature: Buffer): {
+    signature: Buffer;
+    hashType: number;
+} {
     return {
         signature: signature.slice(0, 64),
-        hashType:
-            signature.slice(64)[0] || transaction_1.Transaction.SIGHASH_DEFAULT,
+        hashType: signature.slice(64)[0] || Transaction.SIGHASH_DEFAULT,
     };
 }
-function extractTaprootSigs(input) {
-    const sigs = [];
+
+function extractTaprootSigs(input: PsbtInput): Buffer[] {
+    const sigs: Buffer[] = [];
     if (input.tapKeySig) sigs.push(input.tapKeySig);
-    if (input.tapScriptSig)
-        sigs.push(...input.tapScriptSig.map(s => s.signature));
+    if (input.tapScriptSig) sigs.push(...input.tapScriptSig.map((s) => s.signature));
     if (!sigs.length) {
-        const finalTapKeySig = getTapKeySigFromWitness(
-            input.finalScriptWitness,
-        );
+        const finalTapKeySig = getTapKeySigFromWitness(input.finalScriptWitness);
         if (finalTapKeySig) sigs.push(finalTapKeySig);
     }
+
     return sigs;
 }
-function getTapKeySigFromWitness(finalScriptWitness) {
+
+export function getTapKeySigFromWitness(finalScriptWitness?: Buffer): Buffer | undefined {
     if (!finalScriptWitness) return;
     const witness = finalScriptWitness.slice(2);
     // todo: add schnorr signature validation
     if (witness.length === 64 || witness.length === 65) return witness;
 }
-exports.getTapKeySigFromWitness = getTapKeySigFromWitness;
-function _tapTreeToList(tree, leaves = [], depth = 0) {
-    if (depth > bip341_1.MAX_TAPTREE_DEPTH)
-        throw new Error('Max taptree depth exceeded.');
+
+function _tapTreeToList(tree: Taptree, leaves: TapLeaf[] = [], depth = 0): TapLeaf[] {
+    if (depth > MAX_TAPTREE_DEPTH) throw new Error('Max taptree depth exceeded.');
     if (!tree) return [];
-    if ((0, types_1.isTapleaf)(tree)) {
+    if (isTapleaf(tree)) {
         leaves.push({
             depth,
-            leafVersion: tree.version || bip341_1.LEAF_VERSION_TAPSCRIPT,
+            leafVersion: tree.version || LEAF_VERSION_TAPSCRIPT,
             script: tree.output,
         });
         return leaves;
@@ -222,17 +225,22 @@ function _tapTreeToList(tree, leaves = [], depth = 0) {
     if (tree[1]) _tapTreeToList(tree[1], leaves, depth + 1);
     return leaves;
 }
-function insertLeavesInTree(leaves) {
-    let tree;
+
+// Just like Taptree, but it accepts empty branches
+type PartialTaptree = [PartialTaptree | Tapleaf, PartialTaptree | Tapleaf] | Tapleaf | undefined;
+
+function insertLeavesInTree(leaves: TapLeaf[]): Taptree {
+    let tree: PartialTaptree;
     for (const leaf of leaves) {
         tree = insertLeafInTree(leaf, tree);
         if (!tree) throw new Error(`No room left to insert tapleaf in tree`);
     }
-    return tree;
+
+    return tree as Taptree;
 }
-function insertLeafInTree(leaf, tree, depth = 0) {
-    if (depth > bip341_1.MAX_TAPTREE_DEPTH)
-        throw new Error('Max taptree depth exceeded.');
+
+function insertLeafInTree(leaf: TapLeaf, tree?: PartialTaptree, depth = 0): PartialTaptree {
+    if (depth > MAX_TAPTREE_DEPTH) throw new Error('Max taptree depth exceeded.');
     if (leaf.depth === depth) {
         if (!tree)
             return {
@@ -241,50 +249,53 @@ function insertLeafInTree(leaf, tree, depth = 0) {
             };
         return;
     }
-    if ((0, types_1.isTapleaf)(tree)) return;
+
+    if (isTapleaf(tree)) return;
     const leftSide = insertLeafInTree(leaf, tree && tree[0], depth + 1);
     if (leftSide) return [leftSide, tree && tree[1]];
+
     const rightSide = insertLeafInTree(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);
+    inputData: PsbtOutput,
+    newInputData: PsbtInput,
+    action: string,
+): void {
+    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);
+    inputData: PsbtOutput,
+    newInputData: PsbtOutput,
+    action: string,
+): void {
+    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.
@@ -293,46 +304,43 @@ function checkMixedTaprootAndNonTaprootOutputFields(
  * @param action - The action being performed.
  * @throws {Error} - If the tap leaf is not part of the tap tree.
  */
-function checkIfTapLeafInTree(inputData, newInputData, action) {
+function checkIfTapLeafInTree(inputData: PsbtInput, newInputData: PsbtInput, action: string): void {
     if (newInputData.tapMerkleRoot) {
-        const newLeafsInTree = (newInputData.tapLeafScript || []).every(l =>
+        const newLeafsInTree = (newInputData.tapLeafScript || []).every((l) =>
             isTapLeafInTree(l, newInputData.tapMerkleRoot),
         );
-        const oldLeafsInTree = (inputData.tapLeafScript || []).every(l =>
+        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.`,
-            );
+            throw new Error(`Invalid arguments for Psbt.${action}. Tapleaf not part of taptree.`);
     } else if (inputData.tapMerkleRoot) {
-        const newLeafsInTree = (newInputData.tapLeafScript || []).every(l =>
+        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.`,
-            );
+            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) {
+function isTapLeafInTree(tapLeaf: TapLeafScript, merkleRoot?: Buffer): boolean {
     if (!merkleRoot) return true;
-    const leafHash = (0, bip341_1.tapleafHash)({
+
+    const leafHash = tapleafHash({
         output: tapLeaf.script,
         version: tapLeaf.leafVersion,
     });
-    const rootHash = (0, bip341_1.rootHashFromPath)(
-        tapLeaf.controlBlock,
-        leafHash,
-    );
+
+    const rootHash = 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.
  *
@@ -340,53 +348,58 @@ function isTapLeafInTree(tapLeaf, merkleRoot) {
  * @param tapLeaf - The TapLeafScript object.
  * @returns An array of sorted signatures as Buffers.
  */
-function sortSignatures(input, tapLeaf) {
-    const leafHash = (0, bip341_1.tapleafHash)({
+function sortSignatures(input: PsbtInput, tapLeaf: TapLeafScript): Buffer[] {
+    const leafHash = tapleafHash({
         output: tapLeaf.script,
         version: tapLeaf.leafVersion,
     });
+
     return (input.tapScriptSig || [])
-        .filter(tss => tss.leafHash.equals(leafHash))
-        .map(tss => addPubkeyPositionInScript(tapLeaf.script, tss))
+        .filter((tss) => tss.leafHash.equals(leafHash))
+        .map((tss) => addPubkeyPositionInScript(tapLeaf.script, tss))
         .sort((t1, t2) => t2.positionInScript - t1.positionInScript)
-        .map(t => t.signature);
+        .map((t) => t.signature) as Buffer[];
 }
+
 /**
  * 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) {
+function addPubkeyPositionInScript(script: Buffer, tss: TapScriptSig): TapScriptSigWitPosition {
     return Object.assign(
         {
-            positionInScript: (0, psbtutils_1.pubkeyPositionInScript)(
-                tss.pubkey,
-                script,
-            ),
+            positionInScript: pubkeyPositionInScript(tss.pubkey, script),
         },
         tss,
-    );
+    ) as TapScriptSigWitPosition;
 }
+
 /**
  * Find tapleaf by hash, or get the signed tapleaf with the shortest path.
  */
-function findTapLeafToFinalize(input, inputIndex, leafHashToFinalize) {
+function findTapLeafToFinalize(
+    input: PsbtInput,
+    inputIndex: number,
+    leafHashToFinalize?: Buffer,
+): TapLeafScript {
     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),
-        );
+        .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.
  *
@@ -395,30 +408,34 @@ function findTapLeafToFinalize(input, inputIndex, leafHashToFinalize) {
  * @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)({
+function canFinalizeLeaf(
+    leaf: TapLeafScript,
+    tapScriptSig: TapScriptSig[],
+    hash?: Buffer,
+): boolean {
+    const leafHash = tapleafHash({
         output: leaf.script,
         version: leaf.leafVersion,
     });
     const whiteListedHash = !hash || hash.equals(leafHash);
     return (
-        whiteListedHash &&
-        tapScriptSig.find(tss => tss.leafHash.equals(leafHash)) !== undefined
+        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) {
+function hasNonTaprootFields(io: PsbtInput | PsbtOutput): boolean {
     return (
         io &&
-        !!(
-            io.redeemScript ||
-            io.witnessScript ||
-            (io.bip32Derivation && io.bip32Derivation.length)
-        )
+        !!(io.redeemScript || io.witnessScript || (io.bip32Derivation && io.bip32Derivation.length))
     );
 }
+
+interface TapScriptSigWitPosition extends TapScriptSig {
+    positionInScript: number;
+}