@bitgo/utxo-lib
Version:
Client-side Bitcoin JavaScript library
510 lines • 71.7 kB
JavaScript
"use strict";
/**
* This module provides taproot utilities including the legacy MuSig2 key aggregation
* algorithm used by BitGo's deprecated `p2tr` script type (chains 30, 31).
*
* ## Legacy p2tr vs Standard p2trMusig2
*
* BitGo supports two taproot address types:
*
* 1. **Legacy `p2tr` (chains 30, 31) - DEPRECATED**
* - Uses the `aggregateMuSigPubkeys()` function in this module
* - Based on an older MuSig2 variant that predates BIP327
* - Expects 32-byte x-only pubkeys with even Y coordinates
* - Sorts keys AFTER x-only conversion
* - Corresponds to MuSig2 before the 32-byte to 33-byte key change
* - See: https://github.com/jonasnick/bips/pull/37
*
* 2. **Standard `p2trMusig2` (chains 40, 41) - RECOMMENDED**
* - Uses the `@brandonblack/musig` library (standard BIP327 implementation)
* - Uses full 33-byte compressed pubkeys throughout aggregation
* - Key order affects the resulting aggregate key
* - Fully compatible with the BIP327 specification
*
* ## Key Difference
*
* The critical difference is **when x-only conversion happens**:
* - Legacy: Converts to x-only BEFORE sorting (produces order-independent keys)
* - Standard: Uses 33-byte keys throughout (key order matters)
*
* For the same two pubkeys, these methods produce DIFFERENT aggregate keys because
* the sort order differs between 33-byte and 32-byte representations.
*
* See `modules/utxo-lib/bip-0327/README.md` for detailed comparison and test cases.
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.INITIAL_TAPSCRIPT_VERSION = exports.EVEN_Y_COORD_PREFIX = void 0;
exports.aggregateMuSigPubkeys = aggregateMuSigPubkeys;
exports.serializeScriptSize = serializeScriptSize;
exports.hashTapLeaf = hashTapLeaf;
exports.hashTapBranch = hashTapBranch;
exports.calculateTapTweak = calculateTapTweak;
exports.tapTweakPrivkey = tapTweakPrivkey;
exports.tapTweakPubkey = tapTweakPubkey;
exports.getDepthFirstTaptree = getDepthFirstTaptree;
exports.getHuffmanTaptree = getHuffmanTaptree;
exports.getControlBlock = getControlBlock;
exports.parseTaprootWitness = parseTaprootWitness;
exports.parseControlBlock = parseControlBlock;
exports.getTapleafHash = getTapleafHash;
exports.getTaptreeRoot = getTaptreeRoot;
exports.getTweakedOutputKey = getTweakedOutputKey;
exports.createTaprootOutputScript = createTaprootOutputScript;
exports.getTaprootOutputKey = getTaprootOutputKey;
const assert = require("assert");
const FastPriorityQueue = require("fastpriorityqueue");
const bitcoinjs_lib_1 = require("bitcoinjs-lib");
const secp256k1_1 = require("@bitgo/secp256k1");
const varuint = require('varuint-bitcoin');
/**
* The 0x02 prefix indicating an even Y coordinate which is implicitly assumed
* on all 32 byte x-only pub keys as defined in BIP340.
*/
exports.EVEN_Y_COORD_PREFIX = Buffer.of(0x02);
exports.INITIAL_TAPSCRIPT_VERSION = 0xc0;
/**
* Aggregates a list of public keys into a single public key using the legacy MuSig2 algorithm.
*
* This implements the deprecated key aggregation method used by BitGo's `p2tr` script type
* (chains 30, 31). It corresponds to an older variant of MuSig2 that predates the change
* from 32-byte to 33-byte keys in the BIP327 specification.
*
* ## Algorithm
*
* The implementation follows the MuSig2 key aggregation scheme:
*
* ```
* P = sum_i (μ_i * P_i)
* ```
*
* where:
* - `P_i` is the public key of the i-th signer
* - `μ_i` is the MuSig coefficient computed as:
* - `L = TaggedHash("KeyAgg list", P_1 || P_2 || ... || P_n)`
* - `μ_i = TaggedHash("KeyAgg coefficient", L || P_i)` for most keys
* - `μ_i = 1` for the second unique key (optimization to save an exponentiation)
*
* ## Key Characteristics (Legacy Variant)
*
* 1. **X-only pubkeys**: Expects 32-byte x-only pubkeys (assumes even Y coordinates)
* 2. **Pre-aggregation sorting**: Sorts keys in ascending order BEFORE aggregation
* 3. **Order-independent**: Due to sorting, key order doesn't affect the result
* 4. **33-byte internal representation**: Internally prepends 0x02 prefix for elliptic curve operations
*
* ## Differences from Standard MuSig2 (BIP327)
*
* The standard MuSig2 implementation (`@brandonblack/musig` library):
* - Uses 33-byte compressed pubkeys throughout
* - Does NOT sort keys before aggregation (key order matters)
* - Produces different aggregate keys even for the same set of pubkeys
*
* ## Reference Implementation
*
* This corresponds to `key_agg_bitgo_p2tr_legacy()` in the Python reference implementation
* at `modules/utxo-lib/bip-0327/reference.py`.
*
* @param ecc Elliptic curve implementation
* @param pubkeys List of 32-byte x-only public keys to aggregate (must have even Y coordinates)
* @returns 32-byte Buffer representing the x-only aggregate public key
* @throws {Error} if fewer than 2 pubkeys provided or elliptic curve operations fail
*
* @see modules/utxo-lib/bip-0327/README.md for detailed comparison with standard MuSig2
* @see https://github.com/jonasnick/bips/pull/37 for the MuSig2 specification change
*/
function aggregateMuSigPubkeys(ecc, pubkeys) {
// TODO: Consider enforcing key uniqueness.
assert(pubkeys.length > 1, 'at least two pubkeys are required for musig key aggregation');
// LEGACY BEHAVIOR: Sort the keys in ascending order BEFORE aggregation.
// This makes the aggregate key independent of input order.
// Standard MuSig2 (BIP327) does NOT sort, making key order significant.
pubkeys.sort(Buffer.compare);
// Compute the "KeyAgg list" hash L = TaggedHash("KeyAgg list", P_1 || P_2 || ... || P_n)
// This hash is used to derive the MuSig coefficients for each pubkey.
// In the reference implementation (reference.py), this is done in hash_keys().
const L = bitcoinjs_lib_1.crypto.taggedHash('KeyAgg list', Buffer.concat(pubkeys));
// Find the second unique pubkey in the sorted list.
// This key (and any keys identical to it) will use coefficient μ = 1 as an optimization.
// This saves an expensive point multiplication (see MuSig2* appendix in the MuSig2 paper).
// In the reference implementation, this is get_second_key().
const secondUniquePubkey = pubkeys.find((pubkey) => !pubkeys[0].equals(pubkey));
// For each pubkey P_i, compute the tweaked pubkey μ_i * P_i
// where μ_i is the MuSig coefficient for that key.
const tweakedPubkeys = pubkeys.map((pubkey) => {
// Convert 32-byte x-only pubkey to 33-byte compressed format by prepending 0x02.
// This assumes an even Y coordinate (standard for x-only pubkeys in taproot).
// In the reference implementation, this is done implicitly in key_agg() via lift_x().
const xyPubkey = Buffer.concat([exports.EVEN_Y_COORD_PREFIX, pubkey]);
if (secondUniquePubkey !== undefined && secondUniquePubkey.equals(pubkey)) {
// Optimization: The second unique key gets coefficient μ = 1.
// This means μ_i * P_i = 1 * P_i = P_i (no multiplication needed).
// This saves an expensive elliptic curve point multiplication operation.
// See key_agg_coeff_internal() in reference.py where it returns 1 for pk_ == pk2.
return xyPubkey;
}
// Compute the MuSig coefficient: μ_i = TaggedHash("KeyAgg coefficient", L || P_i)
// In the reference implementation, this is key_agg_coeff_internal().
const c = bitcoinjs_lib_1.crypto.taggedHash('KeyAgg coefficient', Buffer.concat([L, pubkey]));
// Compute the tweaked pubkey: μ_i * P_i (elliptic curve point multiplication)
const tweakedPubkey = ecc.pointMultiply(xyPubkey, c);
if (!tweakedPubkey) {
throw new Error('Failed to multiply pubkey by coefficient');
}
return tweakedPubkey;
});
// Sum all the tweaked pubkeys to get the aggregate pubkey:
// P = sum_i (μ_i * P_i) = μ_1*P_1 + μ_2*P_2 + ... + μ_n*P_n
// This is elliptic curve point addition.
const aggregatePubkey = tweakedPubkeys.reduce((prev, curr) => {
const next = ecc.pointAdd(prev, curr);
if (!next)
throw new Error('Failed to sum pubkeys');
return next;
});
// Convert the aggregate pubkey from 33-byte compressed format back to 32-byte x-only format
// by removing the first byte (the Y coordinate prefix).
// In the reference implementation, this is done by get_xonly_pk() which calls xbytes().
return aggregatePubkey.slice(1);
}
/**
* Encodes the length of a script as a bitcoin variable length integer.
* @param script
* @returns
*/
function serializeScriptSize(script) {
return varuint.encode(script.length);
}
/**
* Gets a tapleaf tagged hash from a script.
* @param script
* @returns
*/
function hashTapLeaf(script, leafVersion = exports.INITIAL_TAPSCRIPT_VERSION) {
const size = serializeScriptSize(script);
return bitcoinjs_lib_1.crypto.taggedHash('TapLeaf', Buffer.concat([Buffer.of(leafVersion), size, script]));
}
/**
* Creates a lexicographically sorted tapbranch from two child taptree nodes
* and returns its tagged hash.
* @param child1
* @param child2
* @returns the tagged tapbranch hash
*/
function hashTapBranch(child1, child2) {
// sort the children lexicographically
const sortedChildren = [child1, child2].sort(Buffer.compare);
return bitcoinjs_lib_1.crypto.taggedHash('TapBranch', Buffer.concat(sortedChildren));
}
function calculateTapTweak(pubkey, taptreeRoot) {
if (pubkey.length !== 32) {
throw new Error(`Invalid pubkey size ${pubkey.length}.`);
}
if (taptreeRoot) {
if (taptreeRoot.length !== 32) {
throw new Error(`Invalid taptreeRoot size ${taptreeRoot.length}.`);
}
return bitcoinjs_lib_1.crypto.taggedHash('TapTweak', Buffer.concat([pubkey, taptreeRoot]));
}
// If the spending conditions do not require a script path, the output key should commit to an
// unspendable script path instead of having no script path.
// https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#cite_note-22
return bitcoinjs_lib_1.crypto.taggedHash('TapTweak', Buffer.from(pubkey));
}
/**
* Tweaks a privkey, using the tagged hash of its pubkey, and (optionally) a taptree root
* @param ecc Elliptic curve implementation
* @param pubkey public key, used to calculate the tweak
* @param privkey the privkey to tweak
* @param taptreeRoot the taptree root tagged hash
* @returns {Buffer} the tweaked privkey
*/
function tapTweakPrivkey(ecc, pubkey, privkey, taptreeRoot) {
const tapTweak = calculateTapTweak(pubkey, taptreeRoot);
const point = ecc.pointFromScalar(privkey);
if (!point)
throw new Error('Invalid private key');
if (point[0] % 2 === 1)
privkey = ecc.privateNegate(privkey);
const result = ecc.privateAdd(privkey, tapTweak);
if (!result)
throw new Error('Invalid private key');
return result;
}
/**
* Tweaks an internal pubkey, using the tagged hash of itself, and (optionally) a taptree root
* @param ecc Elliptic curve implementation
* @param pubkey the internal pubkey to tweak
* @param taptreeRoot the taptree root tagged hash
* @returns {TweakedPubkey} the tweaked pubkey
*/
function tapTweakPubkey(ecc, pubkey, taptreeRoot) {
const tapTweak = calculateTapTweak(pubkey, taptreeRoot);
const result = ecc.xOnlyPointAddTweak(pubkey, tapTweak);
if (!result)
throw new Error('Invalid pubkey');
return result;
}
function recurseTaptree(leaves, targetDepth = 0) {
const { value, done } = leaves.next();
assert(!done, 'insufficient leaves to reconstruct tap tree');
const [index, leaf] = value;
const tree = {
root: hashTapLeaf(leaf.script, leaf.leafVersion),
paths: [],
};
tree.paths[index] = [];
for (let depth = leaf.depth; depth > targetDepth; depth--) {
const sibling = recurseTaptree(leaves, depth);
tree.paths.forEach((path) => path.push(sibling.root));
sibling.paths.forEach((path) => path.push(tree.root));
tree.root = hashTapBranch(tree.root, sibling.root);
// Merge disjoint sparse arrays of paths into tree.paths
Object.assign(tree.paths, sibling.paths);
}
return tree;
}
/**
* Gets the root hash and hash-paths of a taptree from the depth-first
* construction used in BIP-0371 PSBTs
* @param tree
* @returns {Taptree} the tree, represented by its root hash, and the paths to
* that root from each of the input scripts
*/
function getDepthFirstTaptree(tree) {
const iter = tree.leaves.entries();
const ret = recurseTaptree(iter);
assert(iter.next().done, 'invalid tap tree, no path to some leaves');
return ret;
}
/**
* Gets the root hash of a taptree using a weighted Huffman construction from a
* list of scripts and corresponding weights.
* @param scripts
* @param weights
* @returns {Taptree} the tree, represented by its root hash, and the paths to that root from each of the input scripts
*/
function getHuffmanTaptree(scripts, weights) {
assert(scripts.length > 0, 'at least one script is required to construct a tap tree');
// Create a queue/heap of the provided scripts prioritized according to their
// corresponding weights.
const queue = new FastPriorityQueue((a, b) => {
return a.weight < b.weight;
});
scripts.forEach((script, index) => {
const weight = weights[index] || 1;
assert(weight > 0, 'script weight must be a positive value');
queue.add({
weight,
taggedHash: hashTapLeaf(script),
paths: { [index]: [] },
});
});
// Now that we have a queue of weighted scripts, we begin a loop whereby we
// remove the two lowest weighted items from the queue. We create a tap branch
// node from the two items, and add the branch back to the queue with the
// combined weight of both its children. Each loop reduces the number of items
// in the queue by one, and we repeat until we are left with only one item -
// this becomes the tap tree root.
//
// For example, if we begin with scripts A, B, C, D with weights 6, 3, 1, 1
// After first loop: A(6), B(3), CD(1 + 1)
// After second loop: A(6), B[CD](3 + 2)
// Final loop: A[B[CD]](6+5)
// The final tree will look like:
//
// A[B[CD]]
// / \
// A B[CD]
// / \
// B [CD]
// / \
// C D
//
// This ensures that the spending conditions we believe to have the highest
// probability of being used are further up the tree than less likely scripts,
// thereby reducing the size of the merkle proofs for the more likely scripts.
while (queue.size > 1) {
// We can safely expect two polls to return non-null elements since we've
// checked that the queue has at least two elements before looping.
const child1 = queue.poll();
const child2 = queue.poll();
Object.values(child1.paths).forEach((path) => path.push(child2.taggedHash));
Object.values(child2.paths).forEach((path) => path.push(child1.taggedHash));
queue.add({
taggedHash: hashTapBranch(child1.taggedHash, child2.taggedHash),
weight: child1.weight + child2.weight,
paths: { ...child1.paths, ...child2.paths },
});
}
// After the while loop above completes we should have exactly one element
// remaining in the queue, which we can safely extract below.
const rootNode = queue.poll();
const paths = Object.entries(rootNode.paths).reduce((acc, [index, path]) => {
acc[Number(index)] = path; // TODO: Why doesn't TS know it's a number?
return acc;
}, Array(scripts.length));
return { root: rootNode.taggedHash, paths };
}
function getControlBlock(parity, pubkey, path, leafVersion = exports.INITIAL_TAPSCRIPT_VERSION) {
const parityVersion = leafVersion + parity;
return Buffer.concat([Buffer.of(parityVersion), pubkey, ...path]);
}
/**
* Parses a taproot witness stack and extracts key data elements.
* @param witnessStack
* @returns {ScriptPathWitness|KeyPathWitness} an object representing the
* parsed witness for a script path or key path spend.
* @throws {Error} if the witness stack does not conform to the BIP 341 script validation rules
*/
function parseTaprootWitness(witnessStack) {
let annex;
if (witnessStack.length >= 2 && witnessStack[witnessStack.length - 1][0] === 0x50) {
// If there are at least two witness elements, and the first byte of the last element is
// 0x50, this last element is called annex a and is removed from the witness stack
annex = witnessStack[witnessStack.length - 1];
witnessStack = witnessStack.slice(0, -1);
}
if (witnessStack.length < 1) {
throw new Error('witness stack must have at least one element');
}
else if (witnessStack.length === 1) {
// key path spend
const signature = witnessStack[0];
if (!bitcoinjs_lib_1.script.isCanonicalSchnorrSignature(signature)) {
throw new Error('invalid signature');
}
return { spendType: 'Key', signature, annex };
}
// script path spend
// second to last element is the tapscript
const tapscript = witnessStack[witnessStack.length - 2];
const tapscriptChunks = bitcoinjs_lib_1.script.decompile(tapscript);
if (!tapscriptChunks || tapscriptChunks.length === 0) {
throw new Error('tapscript is not a valid script');
}
// The last stack element is called the control block c, and must have length 33 + 32m,
// for a value of m that is an integer between 0 and 128, inclusive
const controlBlock = witnessStack[witnessStack.length - 1];
if (controlBlock.length < 33 || controlBlock.length > 33 + 32 * 128 || controlBlock.length % 32 !== 1) {
throw new Error('invalid control block length');
}
return {
spendType: 'Script',
scriptSig: witnessStack.slice(0, -2),
tapscript,
controlBlock,
annex,
};
}
/**
* Parses a taproot control block.
* @param ecc Elliptic curve implementation
* @param controlBlock the control block to parse
* @returns {ControlBlock} the parsed control block
* @throws {Error} if the witness stack does not conform to the BIP 341 script validation rules
*/
function parseControlBlock(ecc, controlBlock) {
if ((controlBlock.length - 1) % 32 !== 0) {
throw new TypeError('Invalid control block length');
}
const parity = controlBlock[0] & 0x01;
// Let p = c[1:33] and let P = lift_x(int(p)) where lift_x and [:] are defined as in BIP340.
// Fail if this point is not on the curve
const internalPubkey = controlBlock.slice(1, 33);
if (!ecc.isXOnlyPoint(internalPubkey)) {
throw new Error('internal pubkey is not an EC point');
}
// The leaf version cannot be 0x50 as that would result in ambiguity with the annex.
const leafVersion = controlBlock[0] & 0xfe;
if (leafVersion === 0x50) {
throw new Error('invalid leaf version');
}
const path = [];
for (let j = 33; j < controlBlock.length; j += 32) {
path.push(controlBlock.slice(j, j + 32));
}
return {
parity,
internalPubkey,
leafVersion,
path,
};
}
/**
* Calculates the tapleaf hash from a control block and script.
* @param ecc Elliptic curve implementation
* @param controlBlock the control block, either raw or parsed
* @param tapscript the leaf script corresdponding to the control block
* @returns {Buffer} the tapleaf hash
*/
function getTapleafHash(ecc, controlBlock, tapscript) {
if (Buffer.isBuffer(controlBlock)) {
controlBlock = parseControlBlock(ecc, controlBlock);
}
const { leafVersion } = controlBlock;
return bitcoinjs_lib_1.crypto.taggedHash('TapLeaf', Buffer.concat([Buffer.of(leafVersion), serializeScriptSize(tapscript), tapscript]));
}
/**
* Calculates the taptree root hash from a control block and script.
* @param ecc Elliptic curve implementation
* @param controlBlock the control block, either raw or parsed
* @param tapscript the leaf script corresdponding to the control block
* @param tapleafHash the leaf hash if already calculated
* @returns {Buffer} the taptree root hash
*/
function getTaptreeRoot(ecc, controlBlock, tapscript, tapleafHash) {
if (Buffer.isBuffer(controlBlock)) {
controlBlock = parseControlBlock(ecc, controlBlock);
}
const { path } = controlBlock;
tapleafHash = tapleafHash || getTapleafHash(ecc, controlBlock, tapscript);
// `taptreeMerkleHash` begins as our tapscript tapleaf hash and its value iterates
// through its parent tapbranch hashes until it ends up as the taptree root hash
let taptreeMerkleHash = tapleafHash;
for (const taptreeSiblingHash of path) {
taptreeMerkleHash =
Buffer.compare(taptreeMerkleHash, taptreeSiblingHash) === -1
? bitcoinjs_lib_1.crypto.taggedHash('TapBranch', Buffer.concat([taptreeMerkleHash, taptreeSiblingHash]))
: bitcoinjs_lib_1.crypto.taggedHash('TapBranch', Buffer.concat([taptreeSiblingHash, taptreeMerkleHash]));
}
return taptreeMerkleHash;
}
function getTweakedOutputKey(payment) {
assert(payment.output);
if (payment.output.length === 34) {
return payment.output?.subarray(2);
}
throw new Error(`invalid p2tr tweaked output key size ${payment.output.length}`);
}
/**
* @returns output script for either script path input controlBlock
* & leafScript OR key path input internalPubKey & taptreeRoot
*/
function createTaprootOutputScript(p2trArgs) {
let internalPubKey;
let taptreeRoot;
if ('internalPubKey' in p2trArgs) {
internalPubKey = p2trArgs.internalPubKey;
taptreeRoot = p2trArgs.taptreeRoot;
}
else {
internalPubKey = parseControlBlock(secp256k1_1.ecc, p2trArgs.controlBlock).internalPubkey;
taptreeRoot = getTaptreeRoot(secp256k1_1.ecc, p2trArgs.controlBlock, p2trArgs.leafScript);
}
const outputKey = tapTweakPubkey(secp256k1_1.ecc, internalPubKey, taptreeRoot).xOnlyPubkey;
return bitcoinjs_lib_1.script.compile([bitcoinjs_lib_1.script.OPS.OP_1, Buffer.from(outputKey)]);
}
/**
* @returns x-only taproot output key (tapOutputKey)
*/
function getTaprootOutputKey(outputScript) {
const outputDecompiled = bitcoinjs_lib_1.script.decompile(outputScript);
if (outputDecompiled?.length !== 2) {
throw new Error('invalid taproot output script');
}
const [op1, outputKey] = outputDecompiled;
if (op1 !== bitcoinjs_lib_1.script.OPS.OP_1 || !Buffer.isBuffer(outputKey) || outputKey.length !== 32) {
throw new Error('invalid taproot output script');
}
return outputKey;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taproot.js","sourceRoot":"","sources":["../../src/taproot.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This module provides taproot utilities including the legacy MuSig2 key aggregation\n * algorithm used by BitGo's deprecated `p2tr` script type (chains 30, 31).\n *\n * ## Legacy p2tr vs Standard p2trMusig2\n *\n * BitGo supports two taproot address types:\n *\n * 1. **Legacy `p2tr` (chains 30, 31) - DEPRECATED**\n *    - Uses the `aggregateMuSigPubkeys()` function in this module\n *    - Based on an older MuSig2 variant that predates BIP327\n *    - Expects 32-byte x-only pubkeys with even Y coordinates\n *    - Sorts keys AFTER x-only conversion\n *    - Corresponds to MuSig2 before the 32-byte to 33-byte key change\n *    - See: https://github.com/jonasnick/bips/pull/37\n *\n * 2. **Standard `p2trMusig2` (chains 40, 41) - RECOMMENDED**\n *    - Uses the `@brandonblack/musig` library (standard BIP327 implementation)\n *    - Uses full 33-byte compressed pubkeys throughout aggregation\n *    - Key order affects the resulting aggregate key\n *    - Fully compatible with the BIP327 specification\n *\n * ## Key Difference\n *\n * The critical difference is **when x-only conversion happens**:\n * - Legacy: Converts to x-only BEFORE sorting (produces order-independent keys)\n * - Standard: Uses 33-byte keys throughout (key order matters)\n *\n * For the same two pubkeys, these methods produce DIFFERENT aggregate keys because\n * the sort order differs between 33-byte and 32-byte representations.\n *\n * See `modules/utxo-lib/bip-0327/README.md` for detailed comparison and test cases.\n */\n\nimport { TapTree as PsbtTapTree, TapLeaf as PsbtTapLeaf } from 'bip174/src/lib/interfaces';\nimport assert = require('assert');\nimport FastPriorityQueue = require('fastpriorityqueue');\nimport { script as bscript, crypto as bcrypto, payments as bpayments } from 'bitcoinjs-lib';\nimport { ecc as eccLib } from '@bitgo/secp256k1';\nconst varuint = require('varuint-bitcoin');\n\n/**\n * The 0x02 prefix indicating an even Y coordinate which is implicitly assumed\n * on all 32 byte x-only pub keys as defined in BIP340.\n */\nexport const EVEN_Y_COORD_PREFIX = Buffer.of(0x02);\nexport const INITIAL_TAPSCRIPT_VERSION = 0xc0;\n\nexport interface TinySecp256k1Interface {\n  isXOnlyPoint(p: Uint8Array): boolean;\n  xOnlyPointAddTweak(p: Uint8Array, tweak: Uint8Array): XOnlyPointAddTweakResult | null;\n  pointFromScalar(sk: Uint8Array, compressed?: boolean): Uint8Array | null;\n  pointMultiply(a: Uint8Array, b: Uint8Array): Uint8Array | null;\n  pointAdd(a: Uint8Array, b: Uint8Array): Uint8Array | null;\n  privateAdd(d: Uint8Array, tweak: Uint8Array): Uint8Array | null;\n  privateNegate(d: Uint8Array): Uint8Array;\n}\n\n/**\n * Aggregates a list of public keys into a single public key using the legacy MuSig2 algorithm.\n *\n * This implements the deprecated key aggregation method used by BitGo's `p2tr` script type\n * (chains 30, 31). It corresponds to an older variant of MuSig2 that predates the change\n * from 32-byte to 33-byte keys in the BIP327 specification.\n *\n * ## Algorithm\n *\n * The implementation follows the MuSig2 key aggregation scheme:\n *\n * ```\n * P = sum_i (μ_i * P_i)\n * ```\n *\n * where:\n * - `P_i` is the public key of the i-th signer\n * - `μ_i` is the MuSig coefficient computed as:\n *   - `L = TaggedHash(\"KeyAgg list\", P_1 || P_2 || ... || P_n)`\n *   - `μ_i = TaggedHash(\"KeyAgg coefficient\", L || P_i)` for most keys\n *   - `μ_i = 1` for the second unique key (optimization to save an exponentiation)\n *\n * ## Key Characteristics (Legacy Variant)\n *\n * 1. **X-only pubkeys**: Expects 32-byte x-only pubkeys (assumes even Y coordinates)\n * 2. **Pre-aggregation sorting**: Sorts keys in ascending order BEFORE aggregation\n * 3. **Order-independent**: Due to sorting, key order doesn't affect the result\n * 4. **33-byte internal representation**: Internally prepends 0x02 prefix for elliptic curve operations\n *\n * ## Differences from Standard MuSig2 (BIP327)\n *\n * The standard MuSig2 implementation (`@brandonblack/musig` library):\n * - Uses 33-byte compressed pubkeys throughout\n * - Does NOT sort keys before aggregation (key order matters)\n * - Produces different aggregate keys even for the same set of pubkeys\n *\n * ## Reference Implementation\n *\n * This corresponds to `key_agg_bitgo_p2tr_legacy()` in the Python reference implementation\n * at `modules/utxo-lib/bip-0327/reference.py`.\n *\n * @param ecc Elliptic curve implementation\n * @param pubkeys List of 32-byte x-only public keys to aggregate (must have even Y coordinates)\n * @returns 32-byte Buffer representing the x-only aggregate public key\n * @throws {Error} if fewer than 2 pubkeys provided or elliptic curve operations fail\n *\n * @see modules/utxo-lib/bip-0327/README.md for detailed comparison with standard MuSig2\n * @see https://github.com/jonasnick/bips/pull/37 for the MuSig2 specification change\n */\nexport function aggregateMuSigPubkeys(ecc: TinySecp256k1Interface, pubkeys: Buffer[]): Uint8Array {\n  // TODO: Consider enforcing key uniqueness.\n  assert(pubkeys.length > 1, 'at least two pubkeys are required for musig key aggregation');\n\n  // LEGACY BEHAVIOR: Sort the keys in ascending order BEFORE aggregation.\n  // This makes the aggregate key independent of input order.\n  // Standard MuSig2 (BIP327) does NOT sort, making key order significant.\n  pubkeys.sort(Buffer.compare);\n\n  // Compute the \"KeyAgg list\" hash L = TaggedHash(\"KeyAgg list\", P_1 || P_2 || ... || P_n)\n  // This hash is used to derive the MuSig coefficients for each pubkey.\n  // In the reference implementation (reference.py), this is done in hash_keys().\n  const L = bcrypto.taggedHash('KeyAgg list', Buffer.concat(pubkeys));\n\n  // Find the second unique pubkey in the sorted list.\n  // This key (and any keys identical to it) will use coefficient μ = 1 as an optimization.\n  // This saves an expensive point multiplication (see MuSig2* appendix in the MuSig2 paper).\n  // In the reference implementation, this is get_second_key().\n  const secondUniquePubkey = pubkeys.find((pubkey) => !pubkeys[0].equals(pubkey));\n\n  // For each pubkey P_i, compute the tweaked pubkey μ_i * P_i\n  // where μ_i is the MuSig coefficient for that key.\n  const tweakedPubkeys: Uint8Array[] = pubkeys.map((pubkey) => {\n    // Convert 32-byte x-only pubkey to 33-byte compressed format by prepending 0x02.\n    // This assumes an even Y coordinate (standard for x-only pubkeys in taproot).\n    // In the reference implementation, this is done implicitly in key_agg() via lift_x().\n    const xyPubkey = Buffer.concat([EVEN_Y_COORD_PREFIX, pubkey]);\n\n    if (secondUniquePubkey !== undefined && secondUniquePubkey.equals(pubkey)) {\n      // Optimization: The second unique key gets coefficient μ = 1.\n      // This means μ_i * P_i = 1 * P_i = P_i (no multiplication needed).\n      // This saves an expensive elliptic curve point multiplication operation.\n      // See key_agg_coeff_internal() in reference.py where it returns 1 for pk_ == pk2.\n      return xyPubkey;\n    }\n\n    // Compute the MuSig coefficient: μ_i = TaggedHash(\"KeyAgg coefficient\", L || P_i)\n    // In the reference implementation, this is key_agg_coeff_internal().\n    const c = bcrypto.taggedHash('KeyAgg coefficient', Buffer.concat([L, pubkey]));\n\n    // Compute the tweaked pubkey: μ_i * P_i (elliptic curve point multiplication)\n    const tweakedPubkey = ecc.pointMultiply(xyPubkey, c);\n    if (!tweakedPubkey) {\n      throw new Error('Failed to multiply pubkey by coefficient');\n    }\n    return tweakedPubkey;\n  });\n\n  // Sum all the tweaked pubkeys to get the aggregate pubkey:\n  // P = sum_i (μ_i * P_i) = μ_1*P_1 + μ_2*P_2 + ... + μ_n*P_n\n  // This is elliptic curve point addition.\n  const aggregatePubkey = tweakedPubkeys.reduce((prev, curr) => {\n    const next = 