Simplify HashTree processing, remove footgun

* More clearly show the continuation and base cases in findScriptPath
* Return undefined not empty path when no path is found
  * This would lead to generating an invalid witness
* Tighten the type for HashTree to not allow 1-sided branch nodes

Author: reardencode

src/payments/p2tr.js

@@ -152,6 +152,7 @@ function p2tr(a, opts) {
         version: o.redeemVersion,
       });
       const path = (0, taprootutils_1.findScriptPath)(hashTree, leafHash);
+      if (!path) return;
       const outputKey = tweakKey(a.internalPubkey, hashTree.hash, _ecc());
       if (!outputKey) return;
       const controlBock = buffer_1.Buffer.concat(

src/payments/taprootutils.d.ts

@@ -2,11 +2,15 @@
 import { Tapleaf, Taptree } from '../types';
 export declare const LEAF_VERSION_TAPSCRIPT = 192;
 export declare function rootHashFromPath(controlBlock: Buffer, tapleafMsg: Buffer): Buffer;
-export interface HashTree {
+interface HashLeaf {
     hash: Buffer;
-    left?: HashTree;
-    right?: HashTree;
 }
+interface HashBranch {
+    hash: Buffer;
+    left: HashTree;
+    right: HashTree;
+}
+export declare type HashTree = HashLeaf | HashBranch;
 /**
  * Build the hash tree from the scripts binary tree.
  * The binary tree can be balanced or not.
@@ -20,8 +24,9 @@ export declare function toHashTree(scriptTree: Taptree): HashTree;
  * Given a MAST tree, it finds the path of a particular hash.
  * @param node - the root of the tree
  * @param hash - the hash to search for
- * @returns - and array of hashes representing the path, or an empty array if no pat is found
+ * @returns - and array of hashes representing the path, undefined if no path is found
  */
-export declare function findScriptPath(node: HashTree, hash: Buffer): Buffer[];
+export declare function findScriptPath(node: HashTree, hash: Buffer): Buffer[] | undefined;
 export declare function tapleafHash(leaf: Tapleaf): Buffer;
 export declare function tapTweakHash(pubKey: Buffer, h: Buffer | undefined): Buffer;
+export {};

src/payments/taprootutils.js

@@ -21,6 +21,7 @@ function rootHashFromPath(controlBlock, tapleafMsg) {
   return k[m];
 }
 exports.rootHashFromPath = rootHashFromPath;
+const isHashBranch = ht => 'left' in ht && 'right' in ht;
 /**
  * Build the hash tree from the scripts binary tree.
  * The binary tree can be balanced or not.
@@ -46,22 +47,21 @@ exports.toHashTree = toHashTree;
  * Given a MAST tree, it finds the path of a particular hash.
  * @param node - the root of the tree
  * @param hash - the hash to search for
- * @returns - and array of hashes representing the path, or an empty array if no pat is found
+ * @returns - and array of hashes representing the path, undefined if no path is found
  */
 function findScriptPath(node, hash) {
-  if (node.left) {
-    if (node.left.hash.equals(hash)) return node.right ? [node.right.hash] : [];
-    const leftPath = findScriptPath(node.left, hash);
-    if (leftPath.length)
-      return node.right ? [node.right.hash].concat(leftPath) : leftPath;
-  }
-  if (node.right) {
-    if (node.right.hash.equals(hash)) return node.left ? [node.left.hash] : [];
-    const rightPath = findScriptPath(node.right, hash);
-    if (rightPath.length)
-      return node.left ? [node.left.hash].concat(rightPath) : rightPath;
+  if (!isHashBranch(node)) {
+    if (node.hash.equals(hash)) {
+      return [];
+    } else {
+      return undefined;
+    }
   }
-  return [];
+  const leftPath = findScriptPath(node.left, hash);
+  if (leftPath !== undefined) return [node.right.hash, ...leftPath];
+  const rightPath = findScriptPath(node.right, hash);
+  if (rightPath !== undefined) return [node.left.hash, ...rightPath];
+  return undefined;
 }
 exports.findScriptPath = findScriptPath;
 function tapleafHash(leaf) {

ts_src/payments/p2tr.ts

@@ -169,6 +169,7 @@ export function p2tr(a: Payment, opts?: PaymentOpts): Payment {
         version: o.redeemVersion,
       });
       const path = findScriptPath(hashTree, leafHash);
+      if (!path) return;
       const outputKey = tweakKey(a.internalPubkey, hashTree.hash, _ecc());
       if (!outputKey) return;
       const controlBock = NBuffer.concat(

ts_src/payments/taprootutils.ts

@@ -27,12 +27,21 @@ export function rootHashFromPath(
   return k[m];
 }
 
-export interface HashTree {
+interface HashLeaf {
   hash: Buffer;
-  left?: HashTree;
-  right?: HashTree;
 }
 
+interface HashBranch {
+  hash: Buffer;
+  left: HashTree;
+  right: HashTree;
+}
+
+const isHashBranch = (ht: HashTree): ht is HashBranch =>
+  'left' in ht && 'right' in ht;
+
+export type HashTree = HashLeaf | HashBranch;
+
 /**
  * Build the hash tree from the scripts binary tree.
  * The binary tree can be balanced or not.
@@ -59,24 +68,27 @@ export function toHashTree(scriptTree: Taptree): HashTree {
  * Given a MAST tree, it finds the path of a particular hash.
  * @param node - the root of the tree
  * @param hash - the hash to search for
- * @returns - and array of hashes representing the path, or an empty array if no pat is found
+ * @returns - and array of hashes representing the path, undefined if no path is found
  */
-export function findScriptPath(node: HashTree, hash: Buffer): Buffer[] {
-  if (node.left) {
-    if (node.left.hash.equals(hash)) return node.right ? [node.right.hash] : [];
-    const leftPath = findScriptPath(node.left, hash);
-    if (leftPath.length)
-      return node.right ? [node.right.hash].concat(leftPath) : leftPath;
+export function findScriptPath(
+  node: HashTree,
+  hash: Buffer,
+): Buffer[] | undefined {
+  if (!isHashBranch(node)) {
+    if (node.hash.equals(hash)) {
+      return [];
+    } else {
+      return undefined;
+    }
   }
 
-  if (node.right) {
-    if (node.right.hash.equals(hash)) return node.left ? [node.left.hash] : [];
-    const rightPath = findScriptPath(node.right, hash);
-    if (rightPath.length)
-      return node.left ? [node.left.hash].concat(rightPath) : rightPath;
-  }
+  const leftPath = findScriptPath(node.left, hash);
+  if (leftPath !== undefined) return [node.right.hash, ...leftPath];
+
+  const rightPath = findScriptPath(node.right, hash);
+  if (rightPath !== undefined) return [node.left.hash, ...rightPath];
 
-  return [];
+  return undefined;
 }
 
 export function tapleafHash(leaf: Tapleaf): Buffer {