refactor: extract tapBranchHash() rename leafHash() to tapBranchHash()

Author: motorina0

src/payments/p2tr.js

@@ -82,8 +82,8 @@ function p2tr(a, opts) {
       const controlBlock = w[w.length - 1];
       const leafVersion = controlBlock[0] & 0b11111110;
       const script = w[w.length - 2];
-      const tapLeafHash = (0, taproot_1.leafHash)(script, leafVersion);
-      return (0, taproot_1.rootHashFromPath)(controlBlock, tapLeafHash);
+      const leafHash = (0, taproot_1.tapLeafHash)(script, leafVersion);
+      return (0, taproot_1.rootHashFromPath)(controlBlock, leafHash);
     }
     return null;
   });
@@ -200,8 +200,8 @@ function p2tr(a, opts) {
           throw new TypeError('Invalid internalPubkey for p2tr witness');
         const leafVersion = controlBlock[0] & 0b11111110;
         const script = witness[witness.length - 2];
-        const tapLeafHash = (0, taproot_1.leafHash)(script, leafVersion);
-        const hash = (0, taproot_1.rootHashFromPath)(controlBlock, tapLeafHash);
+        const leafHash = (0, taproot_1.tapLeafHash)(script, leafVersion);
+        const hash = (0, taproot_1.rootHashFromPath)(controlBlock, leafHash);
         const outputKey = (0, taproot_1.tweakKey)(internalPubkey, hash);
         if (!outputKey)
           // todo: needs test data

src/taproot.d.ts

@@ -2,10 +2,6 @@
 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 leafHash(script: Buffer, version: number): Buffer;
 export declare function rootHashFromPath(controlBlock: Buffer, tapLeafMsg: Buffer): Buffer;
-export interface HashTree {
-    rootHash: Buffer;
-    scritptPath?: Buffer;
-}
 export declare function rootHashFromTree(scripts: TaprootLeaf[]): 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.rootHashFromTree = exports.rootHashFromPath = exports.leafHash = exports.tweakKey = exports.liftX = void 0;
+exports.tapLeafHash = exports.rootHashFromTree = exports.rootHashFromPath = exports.tweakKey = exports.liftX = void 0;
 const buffer_1 = require('buffer');
 const BN = require('bn.js');
 const bcrypto = require('./crypto');
@@ -63,32 +63,16 @@ function tweakKey(pubKey, h) {
   };
 }
 exports.tweakKey = tweakKey;
-function leafHash(script, version) {
-  return bcrypto.taggedHash(
-    TAP_LEAF_TAG,
-    buffer_1.Buffer.concat([
-      buffer_1.Buffer.from([version]),
-      serializeScript(script),
-    ]),
-  );
-}
-exports.leafHash = leafHash;
 function rootHashFromPath(controlBlock, tapLeafMsg) {
   const k = [tapLeafMsg];
   const e = [];
   const m = (controlBlock.length - 33) / 32;
   for (let j = 0; j < m; j++) {
     e[j] = controlBlock.slice(33 + 32 * j, 65 + 32 * j);
     if (k[j].compare(e[j]) < 0) {
-      k[j + 1] = bcrypto.taggedHash(
-        TAP_BRANCH_TAG,
-        buffer_1.Buffer.concat([k[j], e[j]]),
-      );
+      k[j + 1] = tapBranchHash(k[j], e[j]);
     } else {
-      k[j + 1] = bcrypto.taggedHash(
-        TAP_BRANCH_TAG,
-        buffer_1.Buffer.concat([e[j], k[j]]),
-      );
+      k[j + 1] = tapBranchHash(e[j], k[j]);
     }
   }
   return k[m];
@@ -103,20 +87,31 @@ function rootHashFromTree(scripts) {
     script.version = script.version || LEAF_VERSION_TAPSCRIPT;
     if ((script.version & 1) !== 0)
       throw new TypeError('Invalid script version');
-    return leafHash(script.output, script.version);
+    return 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));
   if (leftHash.compare(rightHash) === 1)
     [leftHash, rightHash] = [rightHash, leftHash];
+  return tapBranchHash(leftHash, rightHash);
+}
+exports.rootHashFromTree = rootHashFromTree;
+// todo: rename to tapLeafHash
+function tapLeafHash(script, version) {
   return bcrypto.taggedHash(
-    TAP_BRANCH_TAG,
-    buffer_1.Buffer.concat([leftHash, rightHash]),
+    TAP_LEAF_TAG,
+    buffer_1.Buffer.concat([
+      buffer_1.Buffer.from([version]),
+      serializeScript(script),
+    ]),
   );
 }
-exports.rootHashFromTree = rootHashFromTree;
+exports.tapLeafHash = tapLeafHash;
+function tapBranchHash(a, b) {
+  return bcrypto.taggedHash(TAP_BRANCH_TAG, buffer_1.Buffer.concat([a, b]));
+}
 function serializeScript(s) {
   const varintLen = varuint.encodingLength(s.length);
   const buffer = buffer_1.Buffer.allocUnsafe(varintLen); // better

ts_src/payments/p2tr.ts

@@ -4,7 +4,7 @@ import { typeforce as typef } from '../types';
 import {
   rootHashFromTree,
   rootHashFromPath,
-  leafHash,
+  tapLeafHash,
   tweakKey,
   liftX,
 } from '../taproot';
@@ -94,8 +94,8 @@ export function p2tr(a: Payment, opts?: PaymentOpts): Payment {
       const controlBlock = w[w.length - 1];
       const leafVersion = controlBlock[0] & 0b11111110;
       const script = w[w.length - 2];
-      const tapLeafHash = leafHash(script, leafVersion);
-      return rootHashFromPath(controlBlock, tapLeafHash);
+      const leafHash = tapLeafHash(script, leafVersion);
+      return rootHashFromPath(controlBlock, leafHash);
     }
     return null;
   });
@@ -226,8 +226,8 @@ export function p2tr(a: Payment, opts?: PaymentOpts): Payment {
         const leafVersion = controlBlock[0] & 0b11111110;
         const script = witness[witness.length - 2];
 
-        const tapLeafHash = leafHash(script, leafVersion);
-        const hash = rootHashFromPath(controlBlock, tapLeafHash);
+        const leafHash = tapLeafHash(script, leafVersion);
+        const hash = rootHashFromPath(controlBlock, leafHash);
 
         const outputKey = tweakKey(internalPubkey, hash);
         if (!outputKey)

ts_src/taproot.ts

@@ -78,10 +78,6 @@ export function tweakKey(
   };
 }
 
-export function leafHash(script: Buffer, version: number): Buffer {
-  return bcrypto.taggedHash(TAP_LEAF_TAG, NBuffer.concat([NBuffer.from([version]), serializeScript(script)]));
-}
-
 export function rootHashFromPath(controlBlock: Buffer, tapLeafMsg: Buffer): Buffer {
   const k = [tapLeafMsg];
   const e = [];
@@ -91,15 +87,9 @@ export function rootHashFromPath(controlBlock: Buffer, tapLeafMsg: Buffer): Buff
   for (let j = 0; j < m; j++) {
     e[j] = controlBlock.slice(33 + 32 * j, 65 + 32 * j);
     if (k[j].compare(e[j]) < 0) {
-      k[j + 1] = bcrypto.taggedHash(
-        TAP_BRANCH_TAG,
-        NBuffer.concat([k[j], e[j]]),
-      );
+      k[j + 1] = tapBranchHash(k[j], e[j]);
     } else {
-      k[j + 1] = bcrypto.taggedHash(
-        TAP_BRANCH_TAG,
-        NBuffer.concat([e[j], k[j]]),
-      );
+      k[j + 1] = tapBranchHash(e[j], k[j]);
     }
   }
 
@@ -115,7 +105,7 @@ export function rootHashFromTree(scripts: TaprootLeaf[]): Buffer {
     script.version = script.version || LEAF_VERSION_TAPSCRIPT;
     if ((script.version & 1) !== 0) throw new TypeError('Invalid script version');
 
-    return leafHash(script.output, script.version);
+    return tapLeafHash(script.output, script.version);
   }
   // todo: this is a binary tree, use zero an one index
   const half = Math.trunc(scripts.length / 2);
@@ -124,10 +114,16 @@ export function rootHashFromTree(scripts: TaprootLeaf[]): Buffer {
 
   if (leftHash.compare(rightHash) === 1)
     [leftHash, rightHash] = [rightHash, leftHash];
-  return bcrypto.taggedHash(
-    TAP_BRANCH_TAG,
-    NBuffer.concat([leftHash, rightHash]),
-  );
+  return tapBranchHash(leftHash, rightHash);
+}
+
+// todo: rename to tapLeafHash
+export function tapLeafHash(script: Buffer, version: number): Buffer {
+  return bcrypto.taggedHash(TAP_LEAF_TAG, NBuffer.concat([NBuffer.from([version]), serializeScript(script)]));
+}
+
+function tapBranchHash(a: Buffer, b: Buffer): Buffer {
+  return bcrypto.taggedHash(TAP_BRANCH_TAG, NBuffer.concat([a, b]), );
 }
 
 function serializeScript(s: Buffer): Buffer {