utxo-lib 1.0.1

package/dist/src/taproot.js

@@ -0,0 +1,384 @@
+"use strict";
+// Taproot-specific key aggregation and taptree logic as defined in:
+// https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki
+// https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTweakedOutputKey = exports.getTaptreeRoot = exports.getTapleafHash = exports.parseControlBlock = exports.parseTaprootWitness = exports.getControlBlock = exports.getHuffmanTaptree = exports.getDepthFirstTaptree = exports.tapTweakPubkey = exports.tapTweakPrivkey = exports.hashTapBranch = exports.hashTapLeaf = exports.serializeScriptSize = exports.aggregateMuSigPubkeys = exports.INITIAL_TAPSCRIPT_VERSION = exports.EVEN_Y_COORD_PREFIX = void 0;
+const assert = require("assert");
+const FastPriorityQueue = require("fastpriorityqueue");
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+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 MuSig2* public key
+ * according to the MuSig2 paper.
+ * @param ecc Elliptic curve implementation
+ * @param pubkeys The list of pub keys to aggregate
+ * @returns a 32 byte Buffer representing the aggregate key
+ */
+function aggregateMuSigPubkeys(ecc, pubkeys) {
+    // TODO: Consider enforcing key uniqueness.
+    assert(pubkeys.length > 1, 'at least two pubkeys are required for musig key aggregation');
+    // Sort the keys in ascending order
+    pubkeys.sort(Buffer.compare);
+    // In MuSig all signers contribute key material to a single signing key,
+    // using the equation
+    //
+    //     P = sum_i µ_i * P_i
+    //
+    // where `P_i` is the public key of the `i`th signer and `µ_i` is a so-called
+    // _MuSig coefficient_ computed according to the following equation
+    //
+    // L = H(P_1 || P_2 || ... || P_n)
+    // µ_i = H(L || P_i)
+    const L = bitcoinjs_lib_1.crypto.taggedHash('KeyAgg list', Buffer.concat(pubkeys));
+    const secondUniquePubkey = pubkeys.find((pubkey) => !pubkeys[0].equals(pubkey));
+    const tweakedPubkeys = pubkeys.map((pubkey) => {
+        const xyPubkey = Buffer.concat([exports.EVEN_Y_COORD_PREFIX, pubkey]);
+        if (secondUniquePubkey !== undefined && secondUniquePubkey.equals(pubkey)) {
+            // The second unique key in the pubkey list given to ''KeyAgg'' (as well
+            // as any keys identical to this key) gets the constant KeyAgg
+            // coefficient 1 which saves an exponentiation (see the MuSig2* appendix
+            // in the MuSig2 paper).
+            return xyPubkey;
+        }
+        const c = bitcoinjs_lib_1.crypto.taggedHash('KeyAgg coefficient', Buffer.concat([L, pubkey]));
+        const tweakedPubkey = ecc.pointMultiply(xyPubkey, c);
+        if (!tweakedPubkey) {
+            throw new Error('Failed to multiply pubkey by coefficient');
+        }
+        return tweakedPubkey;
+    });
+    const aggregatePubkey = tweakedPubkeys.reduce((prev, curr) => {
+        const next = ecc.pointAdd(prev, curr);
+        if (!next)
+            throw new Error('Failed to sum pubkeys');
+        return next;
+    });
+    return aggregatePubkey.slice(1);
+}
+exports.aggregateMuSigPubkeys = aggregateMuSigPubkeys;
+/**
+ * Encodes the length of a script as a bitcoin variable length integer.
+ * @param script
+ * @returns
+ */
+function serializeScriptSize(script) {
+    return varuint.encode(script.length);
+}
+exports.serializeScriptSize = serializeScriptSize;
+/**
+ * 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]));
+}
+exports.hashTapLeaf = hashTapLeaf;
+/**
+ * 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));
+}
+exports.hashTapBranch = hashTapBranch;
+function calculateTapTweak(pubkey, taptreeRoot) {
+    if (taptreeRoot) {
+        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;
+}
+exports.tapTweakPrivkey = tapTweakPrivkey;
+/**
+ * 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;
+}
+exports.tapTweakPubkey = tapTweakPubkey;
+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;
+}
+exports.getDepthFirstTaptree = getDepthFirstTaptree;
+/**
+ * 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 };
+}
+exports.getHuffmanTaptree = getHuffmanTaptree;
+function getControlBlock(parity, pubkey, path, leafVersion = exports.INITIAL_TAPSCRIPT_VERSION) {
+    const parityVersion = leafVersion + parity;
+    return Buffer.concat([Buffer.of(parityVersion), pubkey, ...path]);
+}
+exports.getControlBlock = getControlBlock;
+/**
+ * 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,
+    };
+}
+exports.parseTaprootWitness = parseTaprootWitness;
+/**
+ * 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,
+    };
+}
+exports.parseControlBlock = parseControlBlock;
+/**
+ * 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]));
+}
+exports.getTapleafHash = getTapleafHash;
+/**
+ * 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;
+}
+exports.getTaptreeRoot = getTaptreeRoot;
+function getTweakedOutputKey(payment) {
+    var _a;
+    assert(payment.output);
+    if (payment.output.length === 34) {
+        return (_a = payment.output) === null || _a === void 0 ? void 0 : _a.subarray(2);
+    }
+    throw new Error(`invalid p2tr tweaked output key size ${payment.output.length}`);
+}
+exports.getTweakedOutputKey = getTweakedOutputKey;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taproot.js","sourceRoot":"","sources":["../../src/taproot.ts"],"names":[],"mappings":"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","sourcesContent":["// Taproot-specific key aggregation and taptree logic as defined in:\n// https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\n// https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki\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';\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 MuSig2* public key\n * according to the MuSig2 paper.\n * @param ecc Elliptic curve implementation\n * @param pubkeys The list of pub keys to aggregate\n * @returns a 32 byte Buffer representing the aggregate key\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  // Sort the keys in ascending order\n  pubkeys.sort(Buffer.compare);\n\n  // In MuSig all signers contribute key material to a single signing key,\n  // using the equation\n  //\n  //     P = sum_i µ_i * P_i\n  //\n  // where `P_i` is the public key of the `i`th signer and `µ_i` is a so-called\n  // _MuSig coefficient_ computed according to the following equation\n  //\n  // L = H(P_1 || P_2 || ... || P_n)\n  // µ_i = H(L || P_i)\n\n  const L = bcrypto.taggedHash('KeyAgg list', Buffer.concat(pubkeys));\n\n  const secondUniquePubkey = pubkeys.find((pubkey) => !pubkeys[0].equals(pubkey));\n\n  const tweakedPubkeys: Uint8Array[] = pubkeys.map((pubkey) => {\n    const xyPubkey = Buffer.concat([EVEN_Y_COORD_PREFIX, pubkey]);\n\n    if (secondUniquePubkey !== undefined && secondUniquePubkey.equals(pubkey)) {\n      // The second unique key in the pubkey list given to ''KeyAgg'' (as well\n      // as any keys identical to this key) gets the constant KeyAgg\n      // coefficient 1 which saves an exponentiation (see the MuSig2* appendix\n      // in the MuSig2 paper).\n      return xyPubkey;\n    }\n\n    const c = bcrypto.taggedHash('KeyAgg coefficient', Buffer.concat([L, pubkey]));\n\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  const aggregatePubkey = tweakedPubkeys.reduce((prev, curr) => {\n    const next = ecc.pointAdd(prev, curr);\n    if (!next) throw new Error('Failed to sum pubkeys');\n    return next;\n  });\n\n  return aggregatePubkey.slice(1);\n}\n\n/**\n * Encodes the length of a script as a bitcoin variable length integer.\n * @param script\n * @returns\n */\nexport function serializeScriptSize(script: Buffer): Buffer {\n  return varuint.encode(script.length);\n}\n\n/**\n * Gets a tapleaf tagged hash from a script.\n * @param script\n * @returns\n */\nexport function hashTapLeaf(script: Buffer, leafVersion = INITIAL_TAPSCRIPT_VERSION): Buffer {\n  const size = serializeScriptSize(script);\n  return bcrypto.taggedHash('TapLeaf', Buffer.concat([Buffer.of(leafVersion), size, script]));\n}\n\n/**\n * Creates a lexicographically sorted tapbranch from two child taptree nodes\n * and returns its tagged hash.\n * @param child1\n * @param child2\n * @returns the tagged tapbranch hash\n */\nexport function hashTapBranch(child1: Buffer, child2: Buffer): Buffer {\n  // sort the children lexicographically\n  const sortedChildren = [child1, child2].sort(Buffer.compare);\n\n  return bcrypto.taggedHash('TapBranch', Buffer.concat(sortedChildren));\n}\n\nfunction calculateTapTweak(pubkey: Uint8Array, taptreeRoot?: Uint8Array): Uint8Array {\n  if (taptreeRoot) {\n    return bcrypto.taggedHash('TapTweak', Buffer.concat([pubkey, taptreeRoot]));\n  }\n  // If the spending conditions do not require a script path, the output key should commit to an\n  // unspendable script path instead of having no script path.\n  // https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#cite_note-22\n  return bcrypto.taggedHash('TapTweak', Buffer.from(pubkey));\n}\n\n/**\n * Tweaks a privkey, using the tagged hash of its pubkey, and (optionally) a taptree root\n * @param ecc Elliptic curve implementation\n * @param pubkey public key, used to calculate the tweak\n * @param privkey the privkey to tweak\n * @param taptreeRoot the taptree root tagged hash\n * @returns {Buffer} the tweaked privkey\n */\nexport function tapTweakPrivkey(\n  ecc: TinySecp256k1Interface,\n  pubkey: Uint8Array,\n  privkey: Uint8Array,\n  taptreeRoot?: Uint8Array\n): Uint8Array {\n  const tapTweak = calculateTapTweak(pubkey, taptreeRoot);\n\n  const point = ecc.pointFromScalar(privkey);\n  if (!point) throw new Error('Invalid private key');\n  if (point[0] % 2 === 1) privkey = ecc.privateNegate(privkey);\n  const result = ecc.privateAdd(privkey, tapTweak);\n  if (!result) throw new Error('Invalid private key');\n  return result;\n}\n\nexport interface XOnlyPointAddTweakResult {\n  parity: 1 | 0;\n  xOnlyPubkey: Uint8Array;\n}\n\n/**\n * Tweaks an internal pubkey, using the tagged hash of itself, and (optionally) a taptree root\n * @param ecc Elliptic curve implementation\n * @param pubkey the internal pubkey to tweak\n * @param taptreeRoot the taptree root tagged hash\n * @returns {TweakedPubkey} the tweaked pubkey\n */\nexport function tapTweakPubkey(\n  ecc: TinySecp256k1Interface,\n  pubkey: Uint8Array,\n  taptreeRoot?: Buffer\n): XOnlyPointAddTweakResult {\n  const tapTweak = calculateTapTweak(pubkey, taptreeRoot);\n  const result = ecc.xOnlyPointAddTweak(pubkey, tapTweak);\n  if (!result) throw new Error('Invalid pubkey');\n  return result;\n}\n\nexport interface Taptree {\n  root: Buffer;\n  paths: Buffer[][];\n}\n\ninterface WeightedTapScript {\n  /** A TapLeaf or TapBranch tagged hash */\n  taggedHash: Buffer;\n  weight: number;\n  paths: {\n    [index: number]: Buffer[];\n  };\n}\n\nfunction recurseTaptree(leaves: Iterator<[number, PsbtTapLeaf]>, targetDepth = 0): Taptree {\n  const { value, done } = leaves.next();\n  assert(!done, 'insufficient leaves to reconstruct tap tree');\n  const [index, leaf] = value;\n  const tree: Taptree = {\n    root: hashTapLeaf(leaf.script, leaf.leafVersion),\n    paths: [],\n  };\n  tree.paths[index] = [];\n  for (let depth = leaf.depth; depth > targetDepth; depth--) {\n    const sibling = recurseTaptree(leaves, depth);\n    tree.paths.forEach((path) => path.push(sibling.root));\n    sibling.paths.forEach((path) => path.push(tree.root));\n    tree.root = hashTapBranch(tree.root, sibling.root);\n    // Merge disjoint sparse arrays of paths into tree.paths\n    Object.assign(tree.paths, sibling.paths);\n  }\n  return tree;\n}\n\n/**\n * Gets the root hash and hash-paths of a taptree from the depth-first\n * construction used in BIP-0371 PSBTs\n * @param tree\n * @returns {Taptree} the tree, represented by its root hash, and the paths to\n * that root from each of the input scripts\n */\nexport function getDepthFirstTaptree(tree: PsbtTapTree): Taptree {\n  const iter = tree.leaves.entries();\n  const ret = recurseTaptree(iter);\n  assert(iter.next().done, 'invalid tap tree, no path to some leaves');\n  return ret;\n}\n\n/**\n * Gets the root hash of a taptree using a weighted Huffman construction from a\n * list of scripts and corresponding weights.\n * @param scripts\n * @param weights\n * @returns {Taptree} the tree, represented by its root hash, and the paths to that root from each of the input scripts\n */\nexport function getHuffmanTaptree(scripts: Buffer[], weights: Array<number | undefined>): Taptree {\n  assert(scripts.length > 0, 'at least one script is required to construct a tap tree');\n\n  // Create a queue/heap of the provided scripts prioritized according to their\n  // corresponding weights.\n  const queue = new FastPriorityQueue<WeightedTapScript>((a, b): boolean => {\n    return a.weight < b.weight;\n  });\n  scripts.forEach((script, index) => {\n    const weight = weights[index] || 1;\n    assert(weight > 0, 'script weight must be a positive value');\n\n    queue.add({\n      weight,\n      taggedHash: hashTapLeaf(script),\n      paths: { [index]: [] },\n    });\n  });\n\n  // Now that we have a queue of weighted scripts, we begin a loop whereby we\n  // remove the two lowest weighted items from the queue. We create a tap branch\n  // node from the two items, and add the branch back to the queue with the\n  // combined weight of both its children. Each loop reduces the number of items\n  // in the queue by one, and we repeat until we are left with only one item -\n  // this becomes the tap tree root.\n  //\n  // For example, if we begin with scripts A, B, C, D with weights 6, 3, 1, 1\n  // After first loop: A(6), B(3), CD(1 + 1)\n  // After second loop: A(6), B[CD](3 + 2)\n  // Final loop: A[B[CD]](6+5)\n  // The final tree will look like:\n  //\n  //        A[B[CD]]\n  //       /        \\\n  //      A         B[CD]\n  //               /     \\\n  //              B      [CD]\n  //                    /    \\\n  //                   C      D\n  //\n  // This ensures that the spending conditions we believe to have the highest\n  // probability of being used are further up the tree than less likely scripts,\n  // thereby reducing the size of the merkle proofs for the more likely scripts.\n  while (queue.size > 1) {\n    // We can safely expect two polls to return non-null elements since we've\n    // checked that the queue has at least two elements before looping.\n    const child1 = queue.poll() as WeightedTapScript;\n    const child2 = queue.poll() as WeightedTapScript;\n\n    Object.values(child1.paths).forEach((path) => path.push(child2.taggedHash));\n    Object.values(child2.paths).forEach((path) => path.push(child1.taggedHash));\n\n    queue.add({\n      taggedHash: hashTapBranch(child1.taggedHash, child2.taggedHash),\n      weight: child1.weight + child2.weight,\n      paths: { ...child1.paths, ...child2.paths },\n    });\n  }\n\n  // After the while loop above completes we should have exactly one element\n  // remaining in the queue, which we can safely extract below.\n  const rootNode = queue.poll() as WeightedTapScript;\n\n  const paths = Object.entries(rootNode.paths).reduce((acc, [index, path]) => {\n    acc[Number(index)] = path; // TODO: Why doesn't TS know it's a number?\n    return acc;\n  }, Array(scripts.length));\n  return { root: rootNode.taggedHash, paths };\n}\n\nexport function getControlBlock(\n  parity: 0 | 1,\n  pubkey: Uint8Array,\n  path: Buffer[],\n  leafVersion = INITIAL_TAPSCRIPT_VERSION\n): Buffer {\n  const parityVersion = leafVersion + parity;\n\n  return Buffer.concat([Buffer.of(parityVersion), pubkey, ...path]);\n}\n\nexport interface KeyPathWitness {\n  spendType: 'Key';\n  signature: Buffer;\n  annex?: Buffer;\n}\n\nexport interface ScriptPathWitness {\n  spendType: 'Script';\n  scriptSig: Buffer[];\n  tapscript: Buffer;\n  controlBlock: Buffer;\n  annex?: Buffer;\n}\n\nexport interface ControlBlock {\n  parity: number;\n  internalPubkey: Buffer;\n  leafVersion: number;\n  path: Buffer[];\n}\n\n/**\n * Parses a taproot witness stack and extracts key data elements.\n * @param witnessStack\n * @returns {ScriptPathWitness|KeyPathWitness} an object representing the\n * parsed witness for a script path or key path spend.\n * @throws {Error} if the witness stack does not conform to the BIP 341 script validation rules\n */\nexport function parseTaprootWitness(witnessStack: Buffer[]): ScriptPathWitness | KeyPathWitness {\n  let annex;\n  if (witnessStack.length >= 2 && witnessStack[witnessStack.length - 1][0] === 0x50) {\n    // If there are at least two witness elements, and the first byte of the last element is\n    // 0x50, this last element is called annex a and is removed from the witness stack\n    annex = witnessStack[witnessStack.length - 1];\n    witnessStack = witnessStack.slice(0, -1);\n  }\n\n  if (witnessStack.length < 1) {\n    throw new Error('witness stack must have at least one element');\n  } else if (witnessStack.length === 1) {\n    // key path spend\n    const signature = witnessStack[0];\n    if (!bscript.isCanonicalSchnorrSignature(signature)) {\n      throw new Error('invalid signature');\n    }\n    return { spendType: 'Key', signature, annex };\n  }\n\n  // script path spend\n  // second to last element is the tapscript\n  const tapscript = witnessStack[witnessStack.length - 2];\n  const tapscriptChunks = bscript.decompile(tapscript);\n\n  if (!tapscriptChunks || tapscriptChunks.length === 0) {\n    throw new Error('tapscript is not a valid script');\n  }\n\n  // The last stack element is called the control block c, and must have length 33 + 32m,\n  // for a value of m that is an integer between 0 and 128, inclusive\n  const controlBlock = witnessStack[witnessStack.length - 1];\n  if (controlBlock.length < 33 || controlBlock.length > 33 + 32 * 128 || controlBlock.length % 32 !== 1) {\n    throw new Error('invalid control block length');\n  }\n\n  return {\n    spendType: 'Script',\n    scriptSig: witnessStack.slice(0, -2),\n    tapscript,\n    controlBlock,\n    annex,\n  };\n}\n\n/**\n * Parses a taproot control block.\n * @param ecc Elliptic curve implementation\n * @param controlBlock the control block to parse\n * @returns {ControlBlock} the parsed control block\n * @throws {Error} if the witness stack does not conform to the BIP 341 script validation rules\n */\nexport function parseControlBlock(ecc: TinySecp256k1Interface, controlBlock: Buffer): ControlBlock {\n  if ((controlBlock.length - 1) % 32 !== 0) {\n    throw new TypeError('Invalid control block length');\n  }\n\n  const parity = controlBlock[0] & 0x01;\n\n  // Let p = c[1:33] and let P = lift_x(int(p)) where lift_x and [:] are defined as in BIP340.\n  // Fail if this point is not on the curve\n  const internalPubkey = controlBlock.slice(1, 33);\n  if (!ecc.isXOnlyPoint(internalPubkey)) {\n    throw new Error('internal pubkey is not an EC point');\n  }\n\n  // The leaf version cannot be 0x50 as that would result in ambiguity with the annex.\n  const leafVersion = controlBlock[0] & 0xfe;\n  if (leafVersion === 0x50) {\n    throw new Error('invalid leaf version');\n  }\n\n  const path: Buffer[] = [];\n  for (let j = 33; j < controlBlock.length; j += 32) {\n    path.push(controlBlock.slice(j, j + 32));\n  }\n\n  return {\n    parity,\n    internalPubkey,\n    leafVersion,\n    path,\n  };\n}\n\n/**\n * Calculates the tapleaf hash from a control block and script.\n * @param ecc Elliptic curve implementation\n * @param controlBlock the control block, either raw or parsed\n * @param tapscript the leaf script corresdponding to the control block\n * @returns {Buffer} the tapleaf hash\n */\nexport function getTapleafHash(\n  ecc: TinySecp256k1Interface,\n  controlBlock: Buffer | ControlBlock,\n  tapscript: Buffer\n): Buffer {\n  if (Buffer.isBuffer(controlBlock)) {\n    controlBlock = parseControlBlock(ecc, controlBlock);\n  }\n  const { leafVersion } = controlBlock;\n\n  return bcrypto.taggedHash(\n    'TapLeaf',\n    Buffer.concat([Buffer.of(leafVersion), serializeScriptSize(tapscript), tapscript])\n  );\n}\n\n/**\n * Calculates the taptree root hash from a control block and script.\n * @param ecc Elliptic curve implementation\n * @param controlBlock the control block, either raw or parsed\n * @param tapscript the leaf script corresdponding to the control block\n * @param tapleafHash the leaf hash if already calculated\n * @returns {Buffer} the taptree root hash\n */\nexport function getTaptreeRoot(\n  ecc: TinySecp256k1Interface,\n  controlBlock: Buffer | ControlBlock,\n  tapscript: Buffer,\n  tapleafHash?: Buffer\n): Buffer {\n  if (Buffer.isBuffer(controlBlock)) {\n    controlBlock = parseControlBlock(ecc, controlBlock);\n  }\n  const { path } = controlBlock;\n\n  tapleafHash = tapleafHash || getTapleafHash(ecc, controlBlock, tapscript);\n\n  // `taptreeMerkleHash` begins as our tapscript tapleaf hash and its value iterates\n  // through its parent tapbranch hashes until it ends up as the taptree root hash\n  let taptreeMerkleHash = tapleafHash;\n  for (const taptreeSiblingHash of path) {\n    taptreeMerkleHash =\n      Buffer.compare(taptreeMerkleHash, taptreeSiblingHash) === -1\n        ? bcrypto.taggedHash('TapBranch', Buffer.concat([taptreeMerkleHash, taptreeSiblingHash]))\n        : bcrypto.taggedHash('TapBranch', Buffer.concat([taptreeSiblingHash, taptreeMerkleHash]));\n  }\n\n  return taptreeMerkleHash;\n}\n\nexport function getTweakedOutputKey(payment: bpayments.Payment): Buffer {\n  assert(payment.output);\n  if (payment.output.length === 34) {\n    return payment.output?.subarray(2);\n  }\n  throw new Error(`invalid p2tr tweaked output key size ${payment.output.length}`);\n}\n"]}

package/dist/src/templates/multisig/index.d.ts

@@ -0,0 +1,4 @@
+import * as input from './input';
+import * as output from './output';
+export { input, output };
+//# sourceMappingURL=index.d.ts.map

package/dist/src/templates/multisig/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/multisig/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC"}

package/dist/src/templates/multisig/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.output = exports.input = void 0;
+const input = require("./input");
+exports.input = input;
+const output = require("./output");
+exports.output = output;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdGVtcGxhdGVzL211bHRpc2lnL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLGlDQUFpQztBQUd4QixzQkFBSztBQUZkLG1DQUFtQztBQUVuQix3QkFBTSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGlucHV0IGZyb20gJy4vaW5wdXQnO1xuaW1wb3J0ICogYXMgb3V0cHV0IGZyb20gJy4vb3V0cHV0JztcblxuZXhwb3J0IHsgaW5wdXQsIG91dHB1dCB9O1xuIl19

package/dist/src/templates/multisig/input.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { Stack } from '../../';
+export declare function check(script: Buffer | Stack, allowIncomplete?: boolean): boolean;
+export declare namespace check {
+    var toJSON: () => string;
+}
+//# sourceMappingURL=input.d.ts.map

package/dist/src/templates/multisig/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../../../src/templates/multisig/input.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAQ/B,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,EAAE,eAAe,CAAC,EAAE,OAAO,GAAG,OAAO,CAUhF;yBAVe,KAAK"}

package/dist/src/templates/multisig/input.js

@@ -0,0 +1,25 @@
+"use strict";
+// OP_0 [signatures ...]
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = void 0;
+const __1 = require("../../");
+const __2 = require("../../");
+function partialSignature(value) {
+    return value === __2.opcodes.OP_0 || __1.script.isCanonicalScriptSignature(value);
+}
+function check(script, allowIncomplete) {
+    const chunks = __1.script.decompile(script);
+    if (chunks.length < 2)
+        return false;
+    if (chunks[0] !== __2.opcodes.OP_0)
+        return false;
+    if (allowIncomplete) {
+        return chunks.slice(1).every(partialSignature);
+    }
+    return chunks.slice(1).every(__1.script.isCanonicalScriptSignature);
+}
+exports.check = check;
+check.toJSON = () => {
+    return 'multisig input';
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/templates/multisig/output.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { Stack } from '../../';
+export declare function check(script: Buffer | Stack, allowIncomplete?: boolean): boolean;
+export declare namespace check {
+    var toJSON: () => string;
+}
+//# sourceMappingURL=output.d.ts.map

package/dist/src/templates/multisig/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../../src/templates/multisig/output.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAM/B,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,EAAE,eAAe,CAAC,EAAE,OAAO,GAAG,OAAO,CAkBhF;yBAlBe,KAAK"}

package/dist/src/templates/multisig/output.js

@@ -0,0 +1,38 @@
+"use strict";
+// m [pubKeys ...] n OP_CHECKMULTISIG
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = void 0;
+const __1 = require("../../");
+const __2 = require("../../");
+const types = require("bitcoinjs-lib/src/types");
+const OP_INT_BASE = __2.opcodes.OP_RESERVED; // OP_1 - 1
+function check(script, allowIncomplete) {
+    const chunks = __1.script.decompile(script);
+    if (chunks.length < 4)
+        return false;
+    if (chunks[chunks.length - 1] !== __2.opcodes.OP_CHECKMULTISIG)
+        return false;
+    if (!types.Number(chunks[0]))
+        return false;
+    if (!types.Number(chunks[chunks.length - 2]))
+        return false;
+    const m = chunks[0] - OP_INT_BASE;
+    const n = chunks[chunks.length - 2] - OP_INT_BASE;
+    if (m <= 0)
+        return false;
+    if (n > 16)
+        return false;
+    if (m > n)
+        return false;
+    if (n !== chunks.length - 3)
+        return false;
+    if (allowIncomplete)
+        return true;
+    const keys = chunks.slice(1, -2);
+    return keys.every(__1.script.isCanonicalPubKey);
+}
+exports.check = check;
+check.toJSON = () => {
+    return 'multi-sig output';
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/templates/nulldata.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+export declare function check(script: Buffer | Array<number | Buffer>): boolean;
+export declare namespace check {
+    var toJSON: () => string;
+}
+declare const output: {
+    check: typeof check;
+};
+export { output };
+//# sourceMappingURL=nulldata.d.ts.map

package/dist/src/templates/nulldata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nulldata.d.ts","sourceRoot":"","sources":["../../../src/templates/nulldata.ts"],"names":[],"mappings":";AAIA,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,OAAO,CAItE;yBAJe,KAAK;;;AASrB,QAAA,MAAM,MAAM;;CAAY,CAAC;AAEzB,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/dist/src/templates/nulldata.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.output = exports.check = void 0;
+// OP_RETURN {data}
+const __1 = require("../");
+const __2 = require("../");
+function check(script) {
+    const buffer = __1.script.compile(script);
+    return buffer.length > 1 && buffer[0] === __2.opcodes.OP_RETURN;
+}
+exports.check = check;
+check.toJSON = () => {
+    return 'null data output';
+};
+const output = { check };
+exports.output = output;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbGRhdGEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGVtcGxhdGVzL251bGxkYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1CQUFtQjtBQUNuQiwyQkFBd0M7QUFDeEMsMkJBQThCO0FBRTlCLFNBQWdCLEtBQUssQ0FBQyxNQUF1QztJQUMzRCxNQUFNLE1BQU0sR0FBRyxVQUFPLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRXZDLE9BQU8sTUFBTSxDQUFDLE1BQU0sR0FBRyxDQUFDLElBQUksTUFBTSxDQUFDLENBQUMsQ0FBQyxLQUFLLFdBQU8sQ0FBQyxTQUFTLENBQUM7QUFDOUQsQ0FBQztBQUpELHNCQUlDO0FBQ0QsS0FBSyxDQUFDLE1BQU0sR0FBRyxHQUFXLEVBQUU7SUFDMUIsT0FBTyxrQkFBa0IsQ0FBQztBQUM1QixDQUFDLENBQUM7QUFFRixNQUFNLE1BQU0sR0FBRyxFQUFFLEtBQUssRUFBRSxDQUFDO0FBRWhCLHdCQUFNIiwic291cmNlc0NvbnRlbnQiOlsiLy8gT1BfUkVUVVJOIHtkYXRhfVxuaW1wb3J0IHsgc2NyaXB0IGFzIGJzY3JpcHQgfSBmcm9tICcuLi8nO1xuaW1wb3J0IHsgb3Bjb2RlcyB9IGZyb20gJy4uLyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBjaGVjayhzY3JpcHQ6IEJ1ZmZlciB8IEFycmF5PG51bWJlciB8IEJ1ZmZlcj4pOiBib29sZWFuIHtcbiAgY29uc3QgYnVmZmVyID0gYnNjcmlwdC5jb21waWxlKHNjcmlwdCk7XG5cbiAgcmV0dXJuIGJ1ZmZlci5sZW5ndGggPiAxICYmIGJ1ZmZlclswXSA9PT0gb3Bjb2Rlcy5PUF9SRVRVUk47XG59XG5jaGVjay50b0pTT04gPSAoKTogc3RyaW5nID0+IHtcbiAgcmV0dXJuICdudWxsIGRhdGEgb3V0cHV0Jztcbn07XG5cbmNvbnN0IG91dHB1dCA9IHsgY2hlY2sgfTtcblxuZXhwb3J0IHsgb3V0cHV0IH07XG4iXX0=

package/dist/src/templates/pubkey/index.d.ts

@@ -0,0 +1,4 @@
+import * as input from './input';
+import * as output from './output';
+export { input, output };
+//# sourceMappingURL=index.d.ts.map

package/dist/src/templates/pubkey/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/pubkey/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC"}

package/dist/src/templates/pubkey/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.output = exports.input = void 0;
+const input = require("./input");
+exports.input = input;
+const output = require("./output");
+exports.output = output;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdGVtcGxhdGVzL3B1YmtleS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpQ0FBaUM7QUFHeEIsc0JBQUs7QUFGZCxtQ0FBbUM7QUFFbkIsd0JBQU0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBpbnB1dCBmcm9tICcuL2lucHV0JztcbmltcG9ydCAqIGFzIG91dHB1dCBmcm9tICcuL291dHB1dCc7XG5cbmV4cG9ydCB7IGlucHV0LCBvdXRwdXQgfTtcbiJdfQ==

package/dist/src/templates/pubkey/input.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { Stack } from '../../';
+export declare function check(script: Buffer | Stack): boolean;
+export declare namespace check {
+    var toJSON: () => string;
+}
+//# sourceMappingURL=input.d.ts.map