feat: support taproot for signAllInputsHD

src/payments/bip341.d.ts

@@ -34,6 +34,13 @@ export declare function rootHashFromPath(controlBlock: Buffer, leafHash: Buffer)
  * @param scriptTree - the tree of scripts to pairwise hash.
  */
 export declare function toHashTree(scriptTree: Taptree): HashTree;
+/**
+ * Calculates the Merkle root from an array of Taproot leaf hashes.
+ *
+ * @param {Buffer[]} leafHashes - Array of Taproot leaf hashes.
+ * @returns {Buffer} - The Merkle root.
+ */
+export declare function calculateScriptTreeMerkleRoot(leafHashes: Buffer[]): Buffer | undefined;
 /**
  * Given a HashTree, finds the path from a particular hash to the root.
  * @param node - the root of the tree

src/payments/bip341.js

@@ -4,6 +4,7 @@ exports.tweakKey =
  exports.tapTweakHash =
  exports.tapleafHash =
  exports.findScriptPath =
+ exports.calculateScriptTreeMerkleRoot =
  exports.toHashTree =
  exports.rootHashFromPath =
  exports.MAX_TAPTREE_DEPTH =
@@ -59,6 +60,35 @@ function toHashTree(scriptTree) {
  };
 }
 exports.toHashTree = toHashTree;
+/**
+ * Calculates the Merkle root from an array of Taproot leaf hashes.
+ *
+ * @param {Buffer[]} leafHashes - Array of Taproot leaf hashes.
+ * @returns {Buffer} - The Merkle root.
+ */
+function calculateScriptTreeMerkleRoot(leafHashes) {
+ if (!leafHashes || leafHashes.length === 0) {
+ return undefined;
+ }
+ // sort the leaf nodes
+ leafHashes.sort(Buffer.compare);
+ // create the initial hash node
+ let currentLevel = leafHashes;
+ // build Merkle Tree
+ while (currentLevel.length > 1) {
+ const nextLevel = [];
+ for (let i = 0; i < currentLevel.length; i += 2) {
+ const left = currentLevel[i];
+ const right = i + 1 < currentLevel.length ? currentLevel[i + 1] : left;
+ nextLevel.push(
+ i + 1 < currentLevel.length ? tapBranchHash(left, right) : left,
+ );
+ }
+ currentLevel = nextLevel;
+ }
+ return currentLevel[0];
+}
+exports.calculateScriptTreeMerkleRoot = calculateScriptTreeMerkleRoot;
 /**
  * Given a HashTree, finds the path from a particular hash to the root.
  * @param node - the root of the tree

src/psbt.d.ts

@@ -160,13 +160,22 @@ export interface HDSigner extends HDSignerBase {
  * Return a 64 byte signature (32 byte r and 32 byte s in that order)
  */
  sign(hash: Buffer): Buffer;
+ /**
+ * Adjusts a keypair for Taproot payments by applying a tweak to derive the internal key.
+ *
+ * In Taproot, a keypair may need to be tweaked to produce an internal key that conforms to the Taproot script.
+ * This tweak process involves modifying the original keypair based on a specific tweak value to ensure compatibility
+ * with the Taproot address format and functionality.
+ */
+ tweak(t: Buffer): Signer;
 }
 /**
  * Same as above but with async sign method
  */
 export interface HDSignerAsync extends HDSignerBase {
  derivePath(path: string): HDSignerAsync;
  sign(hash: Buffer): Promise<Buffer>;
+ tweak(t: Buffer): Signer;
 }
 export interface Signer {
  publicKey: Buffer;

src/psbt.js

@@ -500,10 +500,7 @@ class Psbt {
  }
  return validationResultCount > 0;
  }
- signAllInputsHD(
- hdKeyPair,
- sighashTypes = [transaction_1.Transaction.SIGHASH_ALL],
- ) {
+ signAllInputsHD(hdKeyPair, sighashTypes) {
  if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
  throw new Error('Need HDSigner to sign input');
  }
@@ -521,10 +518,7 @@ class Psbt {
  }
  return this;
  }
- signAllInputsHDAsync(
- hdKeyPair,
- sighashTypes = [transaction_1.Transaction.SIGHASH_ALL],
- ) {
+ signAllInputsHDAsync(hdKeyPair, sighashTypes) {
  return new Promise((resolve, reject) => {
  if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
  return reject(new Error('Need HDSigner to sign input'));
@@ -551,23 +545,15 @@ class Psbt {
  });
  });
  }
- signInputHD(
- inputIndex,
- hdKeyPair,
- sighashTypes = [transaction_1.Transaction.SIGHASH_ALL],
- ) {
+ signInputHD(inputIndex, hdKeyPair, sighashTypes) {
  if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
  throw new Error('Need HDSigner to sign input');
  }
  const signers = getSignersFromHD(inputIndex, this.data.inputs, hdKeyPair);
  signers.forEach(signer => this.signInput(inputIndex, signer, sighashTypes));
  return this;
  }
- signInputHDAsync(
- inputIndex,
- hdKeyPair,
- sighashTypes = [transaction_1.Transaction.SIGHASH_ALL],
- ) {
+ signInputHDAsync(inputIndex, hdKeyPair, sighashTypes) {
  return new Promise((resolve, reject) => {
  if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
  return reject(new Error('Need HDSigner to sign input'));
@@ -1445,6 +1431,9 @@ function getScriptFromInput(inputIndex, input, cache) {
 }
 function getSignersFromHD(inputIndex, inputs, hdKeyPair) {
  const input = (0, utils_1.checkForInput)(inputs, inputIndex);
+ if ((0, bip371_1.isTaprootInput)(input)) {
+ return getTweakSignersFromHD(inputIndex, inputs, hdKeyPair);
+ }
  if (!input.bip32Derivation || input.bip32Derivation.length === 0) {
  throw new Error('Need bip32Derivation to sign with HD');
  }
@@ -1471,6 +1460,39 @@ function getSignersFromHD(inputIndex, inputs, hdKeyPair) {
  });
  return signers;
 }
+function getTweakSignersFromHD(inputIndex, inputs, hdKeyPair) {
+ const input = (0, utils_1.checkForInput)(inputs, inputIndex);
+ if (!input.tapBip32Derivation || input.tapBip32Derivation.length === 0) {
+ throw new Error('Need tapBip32Derivation to sign with HD');
+ }
+ const myDerivations = input.tapBip32Derivation
+ .map(bipDv => {
+ if (bipDv.masterFingerprint.equals(hdKeyPair.fingerprint)) {
+ return bipDv;
+ } else {
+ return;
+ }
+ })
+ .filter(v => !!v);
+ if (myDerivations.length === 0) {
+ throw new Error(
+ 'Need one tapBip32Derivation masterFingerprint to match the HDSigner fingerprint',
+ );
+ }
+ const signers = myDerivations.map(bipDv => {
+ const node = hdKeyPair.derivePath(bipDv.path);
+ if (!bipDv.pubkey.equals((0, bip371_1.toXOnly)(node.publicKey))) {
+ throw new Error('pubkey did not match tapBip32Derivation');
+ }
+ const h = (0, bip341_1.calculateScriptTreeMerkleRoot)(bipDv.leafHashes);
+ const tweakValue = (0, bip341_1.tapTweakHash)(
+ (0, bip371_1.toXOnly)(node.publicKey),
+ h,
+ );
+ return node.tweak(tweakValue);
+ });
+ return signers;
+}
 function getSortedSigs(script, partialSig) {
  const p2ms = payments.p2ms({ output: script });
  // for each pubkey in order of p2ms script

test/integration/taproot.spec.ts

@@ -217,6 +217,163 @@ describe('bitcoinjs-lib (transaction with taproot)', () => {
  });
  });
 
+ it('can create (and broadcast via 3PBP) a taproot key-path spend Transaction of HD wallet by tapBip32Derivation', async () => {
+ const root = bip32.fromSeed(rng(64), regtest);
+ const path = `m/86'/0'/0'/0/0`;
+ const child = root.derivePath(path);
+ const internalKey = toXOnly(child.publicKey);
+
+ const { output, address } = bitcoin.payments.p2tr({
+ internalPubkey: internalKey,
+ network: regtest,
+ });
+
+ // amount from faucet
+ const amount = 42e4;
+ // amount to send
+ const sendAmount = amount - 1e4;
+ // get faucet
+ const unspent = await regtestUtils.faucetComplex(output!, amount);
+
+ const psbt = new bitcoin.Psbt({ network: regtest });
+ psbt.addInput({
+ hash: unspent.txId,
+ index: 0,
+ witnessUtxo: { value: amount, script: output! },
+ tapInternalKey: internalKey,
+ tapBip32Derivation: [
+ {
+ masterFingerprint: root.fingerprint,
+ pubkey: internalKey,
+ path,
+ leafHashes: [],
+ },
+ ],
+ });
+
+ psbt.addOutput({
+ value: sendAmount,
+ address: address!,
+ tapInternalKey: internalKey,
+ });
+
+ await psbt.signAllInputsHD(root);
+
+ psbt.finalizeAllInputs();
+ const tx = psbt.extractTransaction();
+ const rawTx = tx.toBuffer();
+
+ const hex = rawTx.toString('hex');
+
+ await regtestUtils.broadcast(hex);
+ await regtestUtils.verify({
+ txId: tx.getId(),
+ address,
+ vout: 0,
+ value: sendAmount,
+ });
+ });
+
+ it('can create (and broadcast via 3PBP) a taproot script-path spend Transaction with 3 leaves of HD wallet by tapBip32Derivation', async () => {
+ // const root = bip32.fromSeed(rng(64), regtest);
+ const mnemonic =
+ 'praise you muffin lion enable neck grocery crumble super myself license ghost';
+ const seed = bip39.mnemonicToSeedSync(mnemonic);
+ const root = bip32.fromSeed(seed, regtest);
+ const path = `m/86'/0'/0'/0/0`;
+ const child = root.derivePath(path);
+ const internalKey = toXOnly(child.publicKey);
+
+ const leafA = {
+ version: LEAF_VERSION_TAPSCRIPT,
+ output: bitcoin.script.fromASM(
+ `${internalKey.toString('hex')} OP_CHECKSIG`,
+ ),
+ };
+ const leafB = {
+ version: LEAF_VERSION_TAPSCRIPT,
+ output: bitcoin.script.fromASM(
+ `${internalKey.toString('hex')} OP_CHECKSIG`,
+ ),
+ };
+ const leafC = {
+ version: LEAF_VERSION_TAPSCRIPT,
+ output: bitcoin.script.fromASM(
+ `${internalKey.toString('hex')} OP_CHECKSIG`,
+ ),
+ };
+ const scriptTree: Taptree = [
+ {
+ output: leafA.output,
+ },
+ [
+ {
+ output: leafB.output,
+ },
+ {
+ output: leafC.output,
+ },
+ ],
+ ];
+
+ const payment = bitcoin.payments.p2tr({
+ internalPubkey: internalKey,
+ scriptTree,
+ network: regtest,
+ });
+
+ const { output, address } = payment;
+
+ // amount from faucet
+ const amount = 42e4;
+ // amount to send
+ const sendAmount = amount - 1e4;
+ // get faucet
+ const unspent = await regtestUtils.faucetComplex(output!, amount);
+
+ const psbt = new bitcoin.Psbt({ network: regtest });
+ const leafHashes = [
+ tapleafHash(leafA),
+ tapleafHash(leafB),
+ tapleafHash(leafC),
+ ];
+ psbt.addInput({
+ hash: unspent.txId,
+ index: 0,
+ witnessUtxo: { value: amount, script: output! },
+ tapInternalKey: internalKey,
+ tapBip32Derivation: [
+ {
+ masterFingerprint: root.fingerprint,
+ pubkey: internalKey,
+ path,
+ leafHashes,
+ },
+ ],
+ });
+
+ psbt.addOutput({
+ value: sendAmount,
+ script: output!,
+ });
+
+ await psbt.signAllInputsHD(root);
+
+ psbt.finalizeAllInputs();
+ const tx = psbt.extractTransaction();
+ const rawTx = tx.toBuffer();
+
+ const hex = rawTx.toString('hex');
+
+ await regtestUtils.broadcast(hex);
+ await regtestUtils.verify({
+ txId: tx.getId(),
+ address,
+ vout: 0,
+ value: sendAmount,
+ });
+ });
+
  it('can create (and broadcast via 3PBP) a taproot script-path spend Transaction - OP_CHECKSIG', async () => {
  const internalKey = bip32.fromSeed(rng(64), regtest);
  const leafKey = bip32.fromSeed(rng(64), regtest);

ts_src/payments/bip341.ts

@@ -82,6 +82,41 @@ export function toHashTree(scriptTree: Taptree): HashTree {
  };
 }
 
+/**
+ * Calculates the Merkle root from an array of Taproot leaf hashes.
+ *
+ * @param {Buffer[]} leafHashes - Array of Taproot leaf hashes.
+ * @returns {Buffer} - The Merkle root.
+ */
+export function calculateScriptTreeMerkleRoot(
+ leafHashes: Buffer[],
+): Buffer | undefined {
+ if (!leafHashes || leafHashes.length === 0) {
+ return undefined;
+ }
+
+ // sort the leaf nodes
+ leafHashes.sort(Buffer.compare);
+
+ // create the initial hash node
+ let currentLevel = leafHashes;
+
+ // build Merkle Tree
+ while (currentLevel.length > 1) {
+ const nextLevel = [];
+ for (let i = 0; i < currentLevel.length; i += 2) {
+ const left = currentLevel[i];
+ const right = i + 1 < currentLevel.length ? currentLevel[i + 1] : left;
+ nextLevel.push(
+ i + 1 < currentLevel.length ? tapBranchHash(left, right) : left,
+ );
+ }
+ currentLevel = nextLevel;
+ }
+
+ return currentLevel[0];
+}
+
 /**
  * Given a HashTree, finds the path from a particular hash to the root.
  * @param node - the root of the tree