@vbyte/btc-dev 1.0.0

package/dist/lib/script/words.d.ts

@@ -0,0 +1,116 @@
+export declare const OPCODE_MAP: {
+    OP_0: number;
+    OP_PUSHDATA1: number;
+    OP_PUSHDATA2: number;
+    OP_PUSHDATA4: number;
+    OP_1NEGATE: number;
+    OP_SUCCESS80: number;
+    OP_1: number;
+    OP_2: number;
+    OP_3: number;
+    OP_4: number;
+    OP_5: number;
+    OP_6: number;
+    OP_7: number;
+    OP_8: number;
+    OP_9: number;
+    OP_10: number;
+    OP_11: number;
+    OP_12: number;
+    OP_13: number;
+    OP_14: number;
+    OP_15: number;
+    OP_16: number;
+    OP_NOP: number;
+    OP_SUCCESS98: number;
+    OP_IF: number;
+    OP_NOTIF: number;
+    OP_ELSE: number;
+    OP_ENDIF: number;
+    OP_VERIFY: number;
+    OP_RETURN: number;
+    OP_TOALTSTACK: number;
+    OP_FROMALTSTACK: number;
+    OP_2DROP: number;
+    OP_2DUP: number;
+    OP_3DUP: number;
+    OP_2OVER: number;
+    OP_2ROT: number;
+    OP_2SWAP: number;
+    OP_IFDUP: number;
+    OP_DEPTH: number;
+    OP_DROP: number;
+    OP_DUP: number;
+    OP_NIP: number;
+    OP_OVER: number;
+    OP_PICK: number;
+    OP_ROLL: number;
+    OP_ROT: number;
+    OP_SWAP: number;
+    OP_TUCK: number;
+    OP_SUCCESS126: number;
+    OP_SUCCESS127: number;
+    OP_SUCCESS128: number;
+    OP_SUCCESS129: number;
+    OP_SIZE: number;
+    OP_SUCCESS131: number;
+    OP_SUCCESS132: number;
+    OP_SUCCESS133: number;
+    OP_SUCCESS134: number;
+    OP_EQUAL: number;
+    OP_EQUALVERIFY: number;
+    OP_SUCCESS137: number;
+    OP_SUCCESS138: number;
+    OP_1ADD: number;
+    OP_1SUB: number;
+    OP_SUCCESS141: number;
+    OP_SUCCESS142: number;
+    OP_NEGATE: number;
+    OP_ABS: number;
+    OP_NOT: number;
+    OP_0NOTEQUAL: number;
+    OP_ADD: number;
+    OP_SUB: number;
+    OP_SUCCESS149: number;
+    OP_SUCCESS150: number;
+    OP_SUCCESS151: number;
+    OP_SUCCESS152: number;
+    OP_SUCCESS153: number;
+    OP_BOOLAND: number;
+    OP_BOOLOR: number;
+    OP_NUMEQUAL: number;
+    OP_NUMEQUALVERIFY: number;
+    OP_NUMNOTEQUAL: number;
+    OP_LESSTHAN: number;
+    OP_GREATERTHAN: number;
+    OP_LESSTHANOREQUAL: number;
+    OP_GREATERTHANOREQUAL: number;
+    OP_MIN: number;
+    OP_MAX: number;
+    OP_WITHIN: number;
+    OP_RIPEMD160: number;
+    OP_SHA1: number;
+    OP_SHA256: number;
+    OP_HASH160: number;
+    OP_HASH256: number;
+    OP_CODESEPARATOR: number;
+    OP_CHECKSIG: number;
+    OP_CHECKSIGVERIFY: number;
+    OP_CHECKMULTISIG: number;
+    OP_CHECKMULTISIGVERIFY: number;
+    OP_NOP1: number;
+    OP_CHECKLOCKTIMEVERIFY: number;
+    OP_CHECKSEQUENCEVERIFY: number;
+    OP_NOP4: number;
+    OP_NOP5: number;
+    OP_NOP6: number;
+    OP_NOP7: number;
+    OP_NOP8: number;
+    OP_NOP9: number;
+    OP_NOP10: number;
+    OP_CHECKSIGADD: number;
+};
+export declare function get_op_code(num: number): string;
+export declare function get_asm_code(string: string): number;
+export declare function get_op_type(word: number): string;
+export declare function is_valid_op(word: number): boolean;

package/dist/lib/script/words.js

@@ -0,0 +1,164 @@
+export const OPCODE_MAP = {
+    OP_0: 0,
+    OP_PUSHDATA1: 76,
+    OP_PUSHDATA2: 77,
+    OP_PUSHDATA4: 78,
+    OP_1NEGATE: 79,
+    OP_SUCCESS80: 80,
+    OP_1: 81,
+    OP_2: 82,
+    OP_3: 83,
+    OP_4: 84,
+    OP_5: 85,
+    OP_6: 86,
+    OP_7: 87,
+    OP_8: 88,
+    OP_9: 89,
+    OP_10: 90,
+    OP_11: 91,
+    OP_12: 92,
+    OP_13: 93,
+    OP_14: 94,
+    OP_15: 95,
+    OP_16: 96,
+    OP_NOP: 97,
+    OP_SUCCESS98: 98,
+    OP_IF: 99,
+    OP_NOTIF: 100,
+    OP_ELSE: 103,
+    OP_ENDIF: 104,
+    OP_VERIFY: 105,
+    OP_RETURN: 106,
+    OP_TOALTSTACK: 107,
+    OP_FROMALTSTACK: 108,
+    OP_2DROP: 109,
+    OP_2DUP: 110,
+    OP_3DUP: 111,
+    OP_2OVER: 112,
+    OP_2ROT: 113,
+    OP_2SWAP: 114,
+    OP_IFDUP: 115,
+    OP_DEPTH: 116,
+    OP_DROP: 117,
+    OP_DUP: 118,
+    OP_NIP: 119,
+    OP_OVER: 120,
+    OP_PICK: 121,
+    OP_ROLL: 122,
+    OP_ROT: 123,
+    OP_SWAP: 124,
+    OP_TUCK: 125,
+    OP_SUCCESS126: 126,
+    OP_SUCCESS127: 127,
+    OP_SUCCESS128: 128,
+    OP_SUCCESS129: 129,
+    OP_SIZE: 130,
+    OP_SUCCESS131: 131,
+    OP_SUCCESS132: 132,
+    OP_SUCCESS133: 133,
+    OP_SUCCESS134: 134,
+    OP_EQUAL: 135,
+    OP_EQUALVERIFY: 136,
+    OP_SUCCESS137: 137,
+    OP_SUCCESS138: 138,
+    OP_1ADD: 139,
+    OP_1SUB: 140,
+    OP_SUCCESS141: 141,
+    OP_SUCCESS142: 142,
+    OP_NEGATE: 143,
+    OP_ABS: 144,
+    OP_NOT: 145,
+    OP_0NOTEQUAL: 146,
+    OP_ADD: 147,
+    OP_SUB: 148,
+    OP_SUCCESS149: 149,
+    OP_SUCCESS150: 150,
+    OP_SUCCESS151: 151,
+    OP_SUCCESS152: 152,
+    OP_SUCCESS153: 153,
+    OP_BOOLAND: 154,
+    OP_BOOLOR: 155,
+    OP_NUMEQUAL: 156,
+    OP_NUMEQUALVERIFY: 157,
+    OP_NUMNOTEQUAL: 158,
+    OP_LESSTHAN: 159,
+    OP_GREATERTHAN: 160,
+    OP_LESSTHANOREQUAL: 161,
+    OP_GREATERTHANOREQUAL: 162,
+    OP_MIN: 163,
+    OP_MAX: 164,
+    OP_WITHIN: 165,
+    OP_RIPEMD160: 166,
+    OP_SHA1: 167,
+    OP_SHA256: 168,
+    OP_HASH160: 169,
+    OP_HASH256: 170,
+    OP_CODESEPARATOR: 171,
+    OP_CHECKSIG: 172,
+    OP_CHECKSIGVERIFY: 173,
+    OP_CHECKMULTISIG: 174,
+    OP_CHECKMULTISIGVERIFY: 175,
+    OP_NOP1: 176,
+    OP_CHECKLOCKTIMEVERIFY: 177,
+    OP_CHECKSEQUENCEVERIFY: 178,
+    OP_NOP4: 179,
+    OP_NOP5: 180,
+    OP_NOP6: 181,
+    OP_NOP7: 182,
+    OP_NOP8: 183,
+    OP_NOP9: 184,
+    OP_NOP10: 185,
+    OP_CHECKSIGADD: 186
+};
+export function get_op_code(num) {
+    if (num > 186 && num < 255) {
+        return 'OP_SUCCESS' + String(num);
+    }
+    for (const [k, v] of Object.entries(OPCODE_MAP)) {
+        if (v === num)
+            return k;
+    }
+    throw new Error('OPCODE not found:' + String(num));
+}
+export function get_asm_code(string) {
+    for (const [k, v] of Object.entries(OPCODE_MAP)) {
+        if (k === string)
+            return Number(v);
+    }
+    throw new Error('OPCODE not found:' + string);
+}
+export function get_op_type(word) {
+    switch (true) {
+        case (word === 0):
+            return 'opcode';
+        case (word >= 1 && word <= 75):
+            return 'varint';
+        case (word === 76):
+            return 'pushdata1';
+        case (word === 77):
+            return 'pushdata2';
+        case (word === 78):
+            return 'pushdata4';
+        case (word <= 254):
+            return 'opcode';
+        default:
+            throw new Error(`Invalid word range: ${word}`);
+    }
+}
+export function is_valid_op(word) {
+    const MIN_RANGE = 75;
+    const MAX_RANGE = 254;
+    const DISABLED_OPCODES = [];
+    switch (true) {
+        case (typeof (word) !== 'number'):
+            return false;
+        case (word === 0):
+            return true;
+        case (DISABLED_OPCODES.includes(word)):
+            return false;
+        case (MIN_RANGE < word && word < MAX_RANGE):
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/lib/sighash/index.d.ts

@@ -0,0 +1,5 @@
+export * from './segwit.js';
+export * from './sign.js';
+export * from './taproot.js';
+export * from './verify.js';
+export * from './util.js';

package/dist/lib/sighash/index.js

@@ -0,0 +1,5 @@
+export * from './segwit.js';
+export * from './sign.js';
+export * from './taproot.js';
+export * from './verify.js';
+export * from './util.js';

package/dist/lib/sighash/segwit.d.ts

@@ -0,0 +1,3 @@
+import { Buff } from '@vbyte/buff';
+import { SigHashOptions, TxData } from '../../types/index.js';
+export declare function hash_segwit_tx(txdata: TxData, options?: SigHashOptions): Buff;

package/dist/lib/sighash/segwit.js

@@ -0,0 +1,89 @@
+import { Buff } from '@vbyte/buff';
+import { hash160, hash256 } from '@vbyte/micro-lib/hash';
+import { Assert } from '@vbyte/micro-lib';
+import { parse_txinput } from './util.js';
+import { prefix_script_size, decode_script } from '../../lib/script/index.js';
+import { encode_txin_vout, encode_tx_locktime, encode_txin_sequence, encode_txin_txid, encode_vout_value, encode_tx_version, parse_tx_data } from '../../lib/tx/index.js';
+import * as CONST from '../../const.js';
+export function hash_segwit_tx(txdata, options = {}) {
+    const { sigflag = 0x01, txindex } = options;
+    const tx = parse_tx_data(txdata);
+    const is_anypay = (sigflag & 0x80) === 0x80;
+    const flag = sigflag % 0x80;
+    if (!CONST.SIGHASH_SEGWIT.includes(flag)) {
+        throw new Error('Invalid hash type: ' + String(sigflag));
+    }
+    const { version, vin, vout, locktime } = tx;
+    const txinput = parse_txinput(tx, options);
+    const { txid, vout: prevIdx, prevout, sequence } = txinput;
+    const { value } = prevout ?? {};
+    if (value === undefined) {
+        throw new Error('Prevout value is empty!');
+    }
+    let { pubkey, script } = options;
+    if (script === undefined && pubkey !== undefined) {
+        const pkhash = hash160(pubkey).hex;
+        script = `76a914${String(pkhash)}88ac`;
+    }
+    if (script === undefined) {
+        throw new Error('No pubkey / script has been set!');
+    }
+    if (decode_script(script).includes('OP_CODESEPARATOR')) {
+        throw new Error('This library does not currently support the use of OP_CODESEPARATOR in segwit scripts.');
+    }
+    const sighash = [
+        encode_tx_version(version),
+        hash_prevouts(vin, is_anypay),
+        hash_sequence(vin, flag, is_anypay),
+        encode_txin_txid(txid),
+        encode_txin_vout(prevIdx),
+        prefix_script_size(script),
+        encode_vout_value(value),
+        encode_txin_sequence(sequence),
+        hash_outputs(vout, flag, txindex),
+        encode_tx_locktime(locktime),
+        Buff.num(sigflag, 4).reverse()
+    ];
+    return hash256(Buff.join(sighash));
+}
+function hash_prevouts(vin, isAnypay) {
+    if (isAnypay === true) {
+        return Buff.num(0, 32);
+    }
+    const stack = [];
+    for (const { txid, vout } of vin) {
+        stack.push(encode_txin_txid(txid));
+        stack.push(encode_txin_vout(vout));
+    }
+    return hash256(Buff.join(stack));
+}
+function hash_sequence(vin, sigflag, isAnyPay) {
+    if (isAnyPay || sigflag !== 0x01) {
+        return Buff.num(0, 32);
+    }
+    const stack = [];
+    for (const { sequence } of vin) {
+        stack.push(encode_txin_sequence(sequence));
+    }
+    return hash256(Buff.join(stack));
+}
+function hash_outputs(vout, sigflag, idx) {
+    const stack = [];
+    if (sigflag === 0x01) {
+        for (const { value, script_pk } of vout) {
+            stack.push(encode_vout_value(value));
+            stack.push(prefix_script_size(script_pk));
+        }
+        return hash256(Buff.join(stack));
+    }
+    if (sigflag === 0x03) {
+        Assert.ok(idx !== undefined);
+        if (idx < vout.length) {
+            const { value, script_pk } = vout[idx];
+            stack.push(encode_vout_value(value));
+            stack.push(prefix_script_size(script_pk));
+            return hash256(Buff.join(stack));
+        }
+    }
+    return Buff.num(0, 32);
+}

package/dist/lib/sighash/sign.d.ts

@@ -0,0 +1,3 @@
+import type { SigHashOptions, TxData } from '../../types/index.js';
+export declare function sign_segwit_tx(seckey: string, txdata: TxData, options: SigHashOptions): string;
+export declare function sign_taproot_tx(seckey: string, txdata: TxData, options: SigHashOptions): string;

package/dist/lib/sighash/sign.js

@@ -0,0 +1,20 @@
+import { ECC } from '@vbyte/micro-lib';
+import { parse_tx_data } from '../../lib/tx/parse.js';
+import { SIGHASH_DEFAULT } from '../../const.js';
+import { hash_segwit_tx } from './segwit.js';
+import { hash_taproot_tx } from './taproot.js';
+import { format_sigflag } from './util.js';
+export function sign_segwit_tx(seckey, txdata, options) {
+    const tx = parse_tx_data(txdata);
+    const msg = hash_segwit_tx(tx, options);
+    const sig = ECC.sign_ecdsa(seckey, msg).hex;
+    const flag = format_sigflag(options.sigflag ?? SIGHASH_DEFAULT);
+    return sig + flag;
+}
+export function sign_taproot_tx(seckey, txdata, options) {
+    const tx = parse_tx_data(txdata);
+    const msg = hash_taproot_tx(tx, options);
+    const sig = ECC.sign_bip340(seckey, msg).hex;
+    const flag = format_sigflag(options.sigflag ?? 0);
+    return sig + flag;
+}

package/dist/lib/sighash/taproot.d.ts

@@ -0,0 +1,9 @@
+import { Buff } from '@vbyte/buff';
+import type { SigHashOptions, TxData, TxInput, TxOutput } from '../../types/index.js';
+export declare function hash_taproot_tx(template: TxData | string, config?: SigHashOptions): Buff;
+export declare function hash_outpoints(vin: TxInput[]): Buff;
+export declare function hash_sequence(vin: TxInput[]): Buff;
+export declare function hash_amounts(prevouts: TxOutput[]): Buff;
+export declare function hash_scripts(prevouts: TxOutput[]): Buff;
+export declare function hash_outputs(vout: TxOutput[]): Buff;
+export declare function hash_output(vout: TxOutput): Buff;

package/dist/lib/sighash/taproot.js

@@ -0,0 +1,124 @@
+import { Buff } from '@vbyte/buff';
+import { Assert } from '@vbyte/micro-lib';
+import { hash340, sha256 } from '@vbyte/micro-lib/hash';
+import { prefix_script_size } from '../../lib/script/util.js';
+import { encode_tapscript } from '../../lib/taproot/encode.js';
+import { parse_tx_data } from '../../lib/tx/parse.js';
+import * as CONST from '../../const.js';
+import { parse_txinput } from './util.js';
+import { encode_txin_vout, encode_tx_locktime, encode_txin_sequence, encode_txin_txid, encode_vout_value, encode_tx_version } from '../../lib/tx/encode.js';
+export function hash_taproot_tx(template, config = {}) {
+    const { script, txindex, sigflag = 0x00, extflag = 0x00, key_version = 0x00, separator_pos = 0xFFFFFFFF } = config;
+    const tx = parse_tx_data(template);
+    const { version, vin: input, vout: output, locktime } = tx;
+    const txinput = parse_txinput(tx, config);
+    const { txid, vout, sequence, witness = [] } = txinput;
+    if (!CONST.SIGHASH_TAPROOT.includes(sigflag)) {
+        throw new Error('Invalid hash type: ' + String(sigflag));
+    }
+    if (extflag < 0 || extflag > 127) {
+        throw new Error('Extention flag out of range: ' + String(extflag));
+    }
+    let { extension } = config;
+    if (script !== undefined) {
+        extension = encode_tapscript(script).hex;
+    }
+    const is_anypay = (sigflag & 0x80) === 0x80;
+    const annex = get_annex_data(witness);
+    const annexBit = (annex !== undefined) ? 1 : 0;
+    const extendBit = (extension !== undefined) ? 1 : 0;
+    const spendType = ((extflag + extendBit) * 2) + annexBit;
+    const hashtag = hash340('TapSighash');
+    const preimage = [
+        hashtag,
+        Buff.num(0x00, 1),
+        Buff.num(sigflag, 1),
+        encode_tx_version(version),
+        encode_tx_locktime(locktime)
+    ];
+    if (!is_anypay) {
+        const prevouts = input.map(e => get_prevout(e));
+        preimage.push(hash_outpoints(input), hash_amounts(prevouts), hash_scripts(prevouts), hash_sequence(input));
+    }
+    if ((sigflag & 0x03) < 2 || (sigflag & 0x03) > 3) {
+        preimage.push(hash_outputs(output));
+    }
+    preimage.push(Buff.num(spendType, 1));
+    if (is_anypay) {
+        const { value, script_pk } = get_prevout(txinput);
+        preimage.push(encode_txin_txid(txid), encode_txin_vout(vout), encode_vout_value(value), prefix_script_size(script_pk), encode_txin_sequence(sequence));
+    }
+    else {
+        Assert.ok(typeof txindex === 'number');
+        preimage.push(Buff.num(txindex, 4).reverse());
+    }
+    if (annex !== undefined) {
+        preimage.push(annex);
+    }
+    if ((sigflag & 0x03) === 0x03) {
+        Assert.ok(typeof txindex === 'number');
+        preimage.push(hash_output(output[txindex]));
+    }
+    if (extension !== undefined) {
+        preimage.push(Buff.bytes(extension), Buff.num(key_version), Buff.num(separator_pos, 4));
+    }
+    return sha256(Buff.join(preimage));
+}
+export function hash_outpoints(vin) {
+    const stack = [];
+    for (const { txid, vout } of vin) {
+        stack.push(encode_txin_txid(txid));
+        stack.push(encode_txin_vout(vout));
+    }
+    return sha256(Buff.join(stack));
+}
+export function hash_sequence(vin) {
+    const stack = [];
+    for (const { sequence } of vin) {
+        stack.push(encode_txin_sequence(sequence));
+    }
+    return sha256(Buff.join(stack));
+}
+export function hash_amounts(prevouts) {
+    const stack = [];
+    for (const { value } of prevouts) {
+        stack.push(encode_vout_value(value));
+    }
+    return sha256(Buff.join(stack));
+}
+export function hash_scripts(prevouts) {
+    const stack = [];
+    for (const { script_pk } of prevouts) {
+        stack.push(prefix_script_size(script_pk));
+    }
+    return sha256(Buff.join(stack));
+}
+export function hash_outputs(vout) {
+    const stack = [];
+    for (const { value, script_pk } of vout) {
+        stack.push(encode_vout_value(value));
+        stack.push(prefix_script_size(script_pk));
+    }
+    return sha256(Buff.join(stack));
+}
+export function hash_output(vout) {
+    return sha256(encode_vout_value(vout.value), prefix_script_size(vout.script_pk));
+}
+function get_annex_data(witness) {
+    if (witness === undefined)
+        return;
+    if (witness.length < 2)
+        return;
+    const annex = witness.at(-1);
+    if (typeof annex === 'string' && annex.startsWith('50')) {
+        const bytes = Buff.hex(annex).prefix_varint('be');
+        return sha256(bytes);
+    }
+    return undefined;
+}
+function get_prevout(vin) {
+    if (vin.prevout === null) {
+        throw new Error('Prevout data missing for input: ' + String(vin.txid));
+    }
+    return vin.prevout;
+}

package/dist/lib/sighash/util.d.ts

@@ -0,0 +1,3 @@
+import type { SigHashOptions, TxInput, TxData } from '../../types/index.js';
+export declare function parse_txinput(txdata: TxData, config?: SigHashOptions): TxInput;
+export declare function format_sigflag(flag: number): string;

package/dist/lib/sighash/util.js

@@ -0,0 +1,16 @@
+import { Buff } from '@vbyte/buff';
+import { Assert } from '@vbyte/micro-lib';
+export function parse_txinput(txdata, config) {
+    let { txindex, txinput } = config ?? {};
+    if (txindex !== undefined) {
+        if (txindex >= txdata.vin.length) {
+            throw new Error('Input index out of bounds: ' + String(txindex));
+        }
+        txinput = txdata.vin.at(txindex);
+    }
+    Assert.ok(txinput !== undefined);
+    return txinput;
+}
+export function format_sigflag(flag) {
+    return (flag !== 0) ? Buff.num(flag, 1).hex : '';
+}

package/dist/lib/sighash/verify.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/sighash/verify.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/taproot/cblock.d.ts

@@ -0,0 +1,3 @@
+import { TaprootConfig, TaprootContext } from '../../types/index.js';
+export declare function create_taproot(config: TaprootConfig): TaprootContext;
+export declare function verify_taproot(tapkey: string, target: string, cblock: string): boolean;

package/dist/lib/taproot/cblock.js

@@ -0,0 +1,55 @@
+import { Buff } from '@vbyte/buff';
+import { Assert, ECC } from '@vbyte/micro-lib';
+import { merkleize } from './tree.js';
+import { TAPLEAF_DEFAULT_VERSION } from '../../const.js';
+import * as Schema from '../../schema/index.js';
+import { encode_tapbranch, encode_taptweak } from './encode.js';
+import { parse_pubkey_parity, parse_cblock } from './parse.js';
+const DEFAULT_VERSION = TAPLEAF_DEFAULT_VERSION;
+export function create_taproot(config) {
+    Schema.taproot.config.parse(config);
+    const { pubkey, version = DEFAULT_VERSION } = config;
+    const leaves = config.leaves ?? [];
+    const target = (config.target !== undefined)
+        ? Buff.bytes(config.target).hex
+        : undefined;
+    let path = [], taproot;
+    if (leaves.length > 0) {
+        const [root, _, proofs] = merkleize(leaves, target);
+        path = proofs;
+        taproot = root;
+    }
+    else {
+        taproot = target;
+    }
+    const taptweak = encode_taptweak(pubkey, taproot);
+    const twk_key = ECC.tweak_pubkey(pubkey, taptweak, 'ecdsa');
+    const parity = parse_pubkey_parity(twk_key);
+    const tapkey = ECC.serialize_pubkey(twk_key, 'bip340');
+    const cbit = Buff.num(version + parity);
+    const block = [cbit, Buff.bytes(pubkey)];
+    if (path.length > 0) {
+        path.forEach(e => block.push(e));
+    }
+    const cblock = Buff.join(block);
+    return {
+        int_key: Buff.bytes(pubkey).hex,
+        parity,
+        taproot: taproot ?? null,
+        cblock: cblock.hex,
+        tapkey: tapkey.hex,
+        taptweak: taptweak.hex
+    };
+}
+export function verify_taproot(tapkey, target, cblock) {
+    Assert.size(tapkey, 32);
+    const { parity, path, int_key } = parse_cblock(cblock);
+    const ext_key = Buff.join([parity, tapkey]);
+    let branch = Buff.bytes(target).hex;
+    for (const leaf of path) {
+        branch = encode_tapbranch(branch, leaf).hex;
+    }
+    const tap_tweak = encode_taptweak(int_key, branch);
+    const tweaked_key = ECC.tweak_pubkey(int_key, tap_tweak, 'ecdsa');
+    return (ext_key.hex === tweaked_key.hex);
+}

package/dist/lib/taproot/encode.d.ts

@@ -0,0 +1,6 @@
+import { Buff } from '@vbyte/buff';
+export declare function encode_tapscript(script: string | Uint8Array, version?: number): Buff;
+export declare function encode_tapleaf(data: string | Uint8Array, version?: number): Buff;
+export declare function encode_tapbranch(leaf_a: string, leaf_b: string): Buff;
+export declare function encode_leaf_version(version?: number): number;
+export declare function encode_taptweak(pubkey: string | Uint8Array, data?: string | Uint8Array): Buff;

package/dist/lib/taproot/encode.js

@@ -0,0 +1,26 @@
+import { hash340 } from '@vbyte/micro-lib/hash';
+import { Assert } from '@vbyte/micro-lib';
+import { prefix_script_size } from '../../lib/script/index.js';
+import { TAPLEAF_DEFAULT_VERSION } from '../../const.js';
+const DEFAULT_VERSION = TAPLEAF_DEFAULT_VERSION;
+export function encode_tapscript(script, version = DEFAULT_VERSION) {
+    const preimg = prefix_script_size(script);
+    return encode_tapleaf(preimg, version);
+}
+export function encode_tapleaf(data, version = DEFAULT_VERSION) {
+    const vbyte = encode_leaf_version(version);
+    return hash340('TapLeaf', vbyte, data);
+}
+export function encode_tapbranch(leaf_a, leaf_b) {
+    if (leaf_b < leaf_a) {
+        [leaf_a, leaf_b] = [leaf_b, leaf_a];
+    }
+    return hash340('TapBranch', leaf_a, leaf_b);
+}
+export function encode_leaf_version(version = 0xc0) {
+    return version & 0xfe;
+}
+export function encode_taptweak(pubkey, data = new Uint8Array()) {
+    Assert.size(pubkey, 32);
+    return hash340('TapTweak', pubkey, data);
+}

package/dist/lib/taproot/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cblock.js';
+export * from './encode.js';
+export * from './parse.js';
+export * from './tree.js';

package/dist/lib/taproot/index.js

@@ -0,0 +1,4 @@
+export * from './cblock.js';
+export * from './encode.js';
+export * from './parse.js';
+export * from './tree.js';