feat: build control-block as part of witness; update tests

Author: motorina0

src/payments/p2tr.js

@@ -1,6 +1,7 @@
 'use strict';
 Object.defineProperty(exports, '__esModule', { value: true });
 exports.p2tr = void 0;
+const buffer_1 = require('buffer');
 const networks_1 = require('../networks');
 const bscript = require('../script');
 const types_1 = require('../types');
@@ -52,7 +53,7 @@ function p2tr(a, opts) {
     return {
       version,
       prefix: result.prefix,
-      data: Buffer.from(data),
+      data: buffer_1.Buffer.from(data),
     };
   });
   const _witness = lazy.value(() => {
@@ -76,7 +77,7 @@ function p2tr(a, opts) {
   });
   lazy.prop(o, 'hash', () => {
     if (a.hash) return a.hash;
-    if (a.scriptsTree) return (0, taproot_1.rootHashFromTree)(a.scriptsTree);
+    if (a.scriptsTree) return (0, taproot_1.toHashTree)(a.scriptsTree).hash;
     const w = _witness();
     if (w && w.length > 1) {
       const controlBlock = w[w.length - 1];
@@ -118,12 +119,32 @@ function p2tr(a, opts) {
   });
   lazy.prop(o, 'witness', () => {
     if (a.witness) return a.witness;
-    if (!a.signature) return;
-    return [a.signature];
+    if (a.scriptsTree && a.scriptLeaf && a.internalPubkey) {
+      const hashTree = (0, taproot_1.toHashTree)(a.scriptsTree);
+      const leafHash = (0, taproot_1.tapLeafHash)(
+        a.scriptLeaf.output,
+        a.scriptLeaf.version,
+      );
+      const path = (0, taproot_1.findScriptPath)(hashTree, leafHash);
+      const outputKey = (0, taproot_1.tweakKey)(
+        a.internalPubkey,
+        hashTree.hash,
+      );
+      if (!outputKey) return;
+      const version = a.scriptLeaf.version || 0xc0;
+      const controlBock = buffer_1.Buffer.concat(
+        [
+          buffer_1.Buffer.from([version | outputKey.parity]),
+          a.internalPubkey,
+        ].concat(path.reverse()),
+      );
+      return [a.scriptLeaf.output, controlBock];
+    }
+    if (a.signature) return [a.signature];
   });
   // extended validation
   if (opts.validate) {
-    let pubkey = Buffer.from([]);
+    let pubkey = buffer_1.Buffer.from([]);
     if (a.address) {
       if (network && network.bech32 !== _address().prefix)
         throw new TypeError('Invalid prefix or Network mismatch');
@@ -162,7 +183,7 @@ function p2tr(a, opts) {
         throw new TypeError('Invalid pubkey for p2tr');
     }
     if (a.hash && a.scriptsTree) {
-      const hash = (0, taproot_1.rootHashFromTree)(a.scriptsTree);
+      const hash = (0, taproot_1.toHashTree)(a.scriptsTree).hash;
       if (!a.hash.equals(hash)) throw new TypeError('Hash mismatch');
     }
     const witness = _witness();
@@ -208,8 +229,7 @@ function p2tr(a, opts) {
           throw new TypeError('Invalid outputKey for p2tr witness');
         if (pubkey.length && !pubkey.equals(outputKey.x))
           throw new TypeError('Pubkey mismatch for p2tr witness');
-        const controlBlockOddParity = (controlBlock[0] & 1) === 1;
-        if (outputKey.isOdd !== controlBlockOddParity)
+        if (outputKey.parity !== (controlBlock[0] & 1))
           throw new Error('Incorrect parity');
       }
     }

src/taproot.d.ts

@@ -3,5 +3,11 @@ import { TweakedPublicKey, TaprootLeaf } from './types';
 export declare function liftX(buffer: Buffer): Buffer | null;
 export declare function tweakKey(pubKey: Buffer, h: Buffer | undefined): TweakedPublicKey | null;
 export declare function rootHashFromPath(controlBlock: Buffer, tapLeafMsg: Buffer): Buffer;
-export declare function rootHashFromTree(scripts: TaprootLeaf[]): Buffer;
-export declare function tapLeafHash(script: Buffer, version: number): Buffer;
+export interface HashTree {
+    hash: Buffer;
+    left?: HashTree;
+    right?: HashTree;
+}
+export declare function toHashTree(scripts: TaprootLeaf[]): HashTree;
+export declare function findScriptPath(node: HashTree, hash: Buffer): Buffer[];
+export declare function tapLeafHash(script: Buffer, version?: number): Buffer;

src/taproot.js

@@ -1,6 +1,6 @@
 'use strict';
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.tapLeafHash = exports.rootHashFromTree = exports.rootHashFromPath = exports.tweakKey = exports.liftX = void 0;
+exports.tapLeafHash = exports.findScriptPath = exports.toHashTree = exports.rootHashFromPath = exports.tweakKey = exports.liftX = void 0;
 const buffer_1 = require('buffer');
 const BN = require('bn.js');
 const bcrypto = require('./crypto');
@@ -58,7 +58,7 @@ function tweakKey(pubKey, h) {
   if (P === null) return null;
   const Q = pointAddScalar(P, tweakHash);
   return {
-    isOdd: Q[64] % 2 === 1,
+    parity: Q[64] % 2,
     x: Q.slice(1, 33),
   };
 }
@@ -78,28 +78,53 @@ function rootHashFromPath(controlBlock, tapLeafMsg) {
   return k[m];
 }
 exports.rootHashFromPath = rootHashFromPath;
-function rootHashFromTree(scripts) {
+function toHashTree(scripts) {
   if (scripts.length === 1) {
     const script = scripts[0];
     if (Array.isArray(script)) {
-      return rootHashFromTree(script);
+      return toHashTree(script);
     }
     script.version = script.version || LEAF_VERSION_TAPSCRIPT;
     if ((script.version & 1) !== 0)
       throw new TypeError('Invalid script version');
-    return tapLeafHash(script.output, script.version);
+    return {
+      hash: tapLeafHash(script.output, script.version),
+    };
   }
   // todo: this is a binary tree, use zero an one index
   const half = Math.trunc(scripts.length / 2);
-  let leftHash = rootHashFromTree(scripts.slice(0, half));
-  let rightHash = rootHashFromTree(scripts.slice(half));
+  const left = toHashTree(scripts.slice(0, half));
+  const right = toHashTree(scripts.slice(half));
+  let leftHash = left.hash;
+  let rightHash = right.hash;
   if (leftHash.compare(rightHash) === 1)
     [leftHash, rightHash] = [rightHash, leftHash];
-  return tapBranchHash(leftHash, rightHash);
+  return {
+    hash: tapBranchHash(leftHash, rightHash),
+    left,
+    right,
+  };
+}
+exports.toHashTree = toHashTree;
+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;
+  }
+  return [];
 }
-exports.rootHashFromTree = rootHashFromTree;
-// todo: rename to tapLeafHash
+exports.findScriptPath = findScriptPath;
 function tapLeafHash(script, version) {
+  version = version || LEAF_VERSION_TAPSCRIPT;
   return bcrypto.taggedHash(
     TAP_LEAF_TAG,
     buffer_1.Buffer.concat([

src/types.d.ts

@@ -15,7 +15,7 @@ export declare function Satoshi(value: number): boolean;
 export declare const ECPoint: any;
 export declare const Network: any;
 export interface TweakedPublicKey {
-    isOdd: boolean;
+    parity: number;
     x: Buffer;
 }
 export interface TaprootLeaf {