refactor: rename rootHash to rootHashFromPath and computeMastRoot to rootHashFromTree

Author: motorina0

src/payments/p2tr.js

@@ -72,14 +72,14 @@ function p2tr(a, opts) {
   });
   lazy.prop(o, 'hash', () => {
     if (a.hash) return a.hash;
-    if (a.scriptsTree) return (0, taproot_1.computeMastRoot)(a.scriptsTree);
+    if (a.scriptsTree) return (0, taproot_1.rootHashFromTree)(a.scriptsTree);
     const w = _witness();
     if (w && w.length > 1) {
       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.rootHash)(controlBlock, tapLeafHash);
+      return (0, taproot_1.rootHashFromPath)(controlBlock, tapLeafHash);
     }
     return null;
   });
@@ -155,7 +155,7 @@ function p2tr(a, opts) {
         throw new TypeError('Invalid pubkey for p2tr');
     }
     if (a.hash && a.scriptsTree) {
-      const hash = (0, taproot_1.computeMastRoot)(a.scriptsTree);
+      const hash = (0, taproot_1.rootHashFromTree)(a.scriptsTree);
       if (!a.hash.equals(hash)) throw new TypeError('Hash mismatch');
     }
     // todo: review cache
@@ -195,7 +195,7 @@ function p2tr(a, opts) {
         const leafVersion = controlBlock[0] & 0b11111110;
         const script = witness[witness.length - 2];
         const tapLeafHash = (0, taproot_1.leafHash)(script, leafVersion);
-        const hash = (0, taproot_1.rootHash)(controlBlock, tapLeafHash);
+        const hash = (0, taproot_1.rootHashFromPath)(controlBlock, tapLeafHash);
         const outputKey = (0, taproot_1.tweakKey)(internalPubkey, hash);
         if (!outputKey)
           // todo: needs test data

src/taproot.d.ts

@@ -3,5 +3,5 @@ import { TweakedPublicKey } 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 rootHash(controlBlock: Buffer, tapLeafMsg: Buffer): Buffer;
-export declare function computeMastRoot(scripts: any): Buffer;
+export declare function rootHashFromPath(controlBlock: Buffer, tapLeafMsg: Buffer): Buffer;
+export declare function rootHashFromTree(scripts: any): Buffer;

src/taproot.js

@@ -1,6 +1,6 @@
 'use strict';
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.computeMastRoot = exports.rootHash = exports.leafHash = exports.tweakKey = exports.liftX = void 0;
+exports.rootHashFromTree = exports.rootHashFromPath = exports.leafHash = exports.tweakKey = exports.liftX = void 0;
 const buffer_1 = require('buffer');
 const BN = require('bn.js');
 const bcrypto = require('./crypto');
@@ -70,7 +70,7 @@ function leafHash(script, version) {
   ]);
 }
 exports.leafHash = leafHash;
-function rootHash(controlBlock, tapLeafMsg) {
+function rootHashFromPath(controlBlock, tapLeafMsg) {
   const k = [];
   const e = [];
   const m = (controlBlock.length - 33) / 32;
@@ -91,13 +91,13 @@ function rootHash(controlBlock, tapLeafMsg) {
   }
   return k[m];
 }
-exports.rootHash = rootHash;
+exports.rootHashFromPath = rootHashFromPath;
 // todo: solve any[]
-function computeMastRoot(scripts) {
+function rootHashFromTree(scripts) {
   if (scripts.length === 1) {
     const script = scripts[0];
     if (Array.isArray(script)) {
-      return computeMastRoot(script);
+      return rootHashFromTree(script);
     }
     script.version = script.version || LEAF_VERSION_TAPSCRIPT;
     if ((script.version & 1) !== 0) throw new Error('Invalid script version'); // todo typedef error
@@ -113,16 +113,16 @@ function computeMastRoot(scripts) {
   }
   // todo: this is a binary tree, use zero an one index
   const half = Math.trunc(scripts.length / 2);
-  let leftHash = computeMastRoot(scripts.slice(0, half));
-  let rightHash = computeMastRoot(scripts.slice(half));
+  let leftHash = rootHashFromTree(scripts.slice(0, half));
+  let rightHash = rootHashFromTree(scripts.slice(half));
   if (leftHash.compare(rightHash) === 1)
     [leftHash, rightHash] = [rightHash, leftHash];
   return bcrypto.taggedHash(
     TAP_BRANCH_TAG,
     buffer_1.Buffer.concat([leftHash, rightHash]),
   );
 }
-exports.computeMastRoot = computeMastRoot;
+exports.rootHashFromTree = rootHashFromTree;
 function serializeScript(s) {
   const varintLen = varuint.encodingLength(s.length);
   const buffer = buffer_1.Buffer.allocUnsafe(varintLen); // better

ts_src/payments/p2tr.ts

@@ -2,9 +2,9 @@ import { bitcoin as BITCOIN_NETWORK } from '../networks';
 import * as bscript from '../script';
 import { typeforce as typef } from '../types';
 import {
-  computeMastRoot,
+  rootHashFromTree, 
+  rootHashFromPath,
   leafHash,
-  rootHash,
   tweakKey,
   liftX,
 } from '../taproot';
@@ -83,14 +83,14 @@ export function p2tr(a: Payment, opts?: PaymentOpts): Payment {
 
   lazy.prop(o, 'hash', () => {
     if (a.hash) return a.hash;
-    if (a.scriptsTree) return computeMastRoot(a.scriptsTree);
+    if (a.scriptsTree) return rootHashFromTree(a.scriptsTree);
     const w = _witness();
     if (w && w.length > 1) {
       const controlBlock = w[w.length - 1];
       const leafVersion = controlBlock[0] & 0b11111110;
       const script = w[w.length - 2];
       const tapLeafHash = leafHash(script, leafVersion);
-      return rootHash(controlBlock, tapLeafHash);
+      return rootHashFromPath(controlBlock, tapLeafHash);
     }
     return null;
   });
@@ -172,11 +172,10 @@ export function p2tr(a: Payment, opts?: PaymentOpts): Payment {
     }
 
     if (a.hash && a.scriptsTree) {
-      const hash = computeMastRoot(a.scriptsTree);
+      const hash = rootHashFromTree(a.scriptsTree);
       if (!a.hash.equals(hash)) throw new TypeError('Hash mismatch');
     }
 
-    // todo: review cache
     const witness = _witness();
 
     if (witness && witness.length) {
@@ -220,7 +219,7 @@ export function p2tr(a: Payment, opts?: PaymentOpts): Payment {
         const script = witness[witness.length - 2];
 
         const tapLeafHash = leafHash(script, leafVersion);
-        const hash = rootHash(controlBlock, tapLeafHash);
+        const hash = rootHashFromPath(controlBlock, tapLeafHash);
 
         const outputKey = tweakKey(internalPubkey, hash);
         if (!outputKey)

ts_src/taproot.ts

@@ -82,7 +82,7 @@ export function leafHash(script: Buffer, version: number): Buffer {
   return NBuffer.concat([NBuffer.from([version]), serializeScript(script)]);
 }
 
-export function rootHash(controlBlock: Buffer, tapLeafMsg: Buffer): Buffer {
+export function rootHashFromPath(controlBlock: Buffer, tapLeafMsg: Buffer): Buffer {
   const k = [];
   const e = [];
 
@@ -108,11 +108,11 @@ export function rootHash(controlBlock: Buffer, tapLeafMsg: Buffer): Buffer {
 }
 
 // todo: solve any[]
-export function computeMastRoot(scripts: any): Buffer {
+export function rootHashFromTree(scripts: any): Buffer {
   if (scripts.length === 1) {
     const script = scripts[0];
     if (Array.isArray(script)) {
-      return computeMastRoot(script);
+      return rootHashFromTree(script);
     }
     script.version = script.version || LEAF_VERSION_TAPSCRIPT;
     if ((script.version & 1) !== 0) throw new Error('Invalid script version'); // todo typedef error
@@ -128,8 +128,8 @@ export function computeMastRoot(scripts: any): Buffer {
   }
   // todo: this is a binary tree, use zero an one index
   const half = Math.trunc(scripts.length / 2);
-  let leftHash = computeMastRoot(scripts.slice(0, half));
-  let rightHash = computeMastRoot(scripts.slice(half));
+  let leftHash = rootHashFromTree(scripts.slice(0, half));
+  let rightHash = rootHashFromTree(scripts.slice(half));
 
   if (leftHash.compare(rightHash) === 1)
     [leftHash, rightHash] = [rightHash, leftHash];