@vbyte/btc-dev 1.1.8 → 2.1.0

package/dist/lib/sighash/taproot.js

@@ -1,26 +1,29 @@
-import { Buff } from '@vbyte/buff';
-import { Assert } from '@vbyte/micro-lib';
-import { hash340, sha256 } from '@vbyte/micro-lib/hash';
-import { encode_tapscript } from '../../lib/taproot/encode.js';
-import { parse_tx } from '../../lib/tx/parse.js';
-import * as CONST from '../../const.js';
-import { parse_txinput, get_annex_data, get_prevout } from './util.js';
-import { encode_txin_vout, encode_tx_locktime, encode_txin_sequence, encode_txin_txid, encode_vout_value, encode_tx_version, encode_script_data } from '../../lib/tx/encode.js';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/util";
+import { hash340, sha256 } from "@vbyte/crypto/hash";
+import * as CONST from "../../const.js";
+import { ValidationError } from "../../error.js";
+import { encode_tapscript } from "../../lib/taproot/encode.js";
+import { encode_script_data, encode_tx_locktime, encode_tx_version, encode_txin_sequence, encode_txin_txid, encode_txin_vout, encode_vout_value, } from "../../lib/tx/encode.js";
+import { parse_tx } from "../../lib/tx/parse.js";
+import { get_annex_data, get_prevout, parse_txinput } from "./util.js";
 export function hash_taproot_tx(template, config = {}) {
     const preimage = get_taproot_tx_preimage(template, config);
-    return hash340('TapSighash', preimage);
+    return hash340("TapSighash", preimage);
 }
 export function get_taproot_tx_preimage(template, config = {}) {
-    const { script, txindex, sigflag = 0x00, extflag = 0x00, key_version = 0x00, separator_pos = 0xFFFFFFFF } = config;
+    const { script, txindex, sigflag = 0x00, extflag = 0x00, key_version = 0x00, separator_pos = 0xffffffff, } = config;
     const tx = parse_tx(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));
+        throw new ValidationError(`invalid taproot sighash type: 0x${sigflag.toString(16)}. ` +
+            `Valid values: SIGHASH_DEFAULT (0x00), SIGHASH_ALL (0x01), SIGHASH_NONE (0x02), SIGHASH_SINGLE (0x03), ` +
+            `or combined with ANYONECANPAY (0x81, 0x82, 0x83)`);
     }
     if (extflag < 0 || extflag > 127) {
-        throw new Error('Extention flag out of range: ' + String(extflag));
+        throw new ValidationError(`extension flag out of range: ${extflag}. Valid range is 0-127`);
     }
     let { extension } = config;
     if (script !== undefined) {
@@ -28,17 +31,17 @@ export function get_taproot_tx_preimage(template, config = {}) {
     }
     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 annexBit = annex !== undefined ? 1 : 0;
+    const extendBit = extension !== undefined ? 1 : 0;
+    const spendType = (extflag + extendBit) * 2 + annexBit;
     const preimage = [
         Buff.num(0x00, 1),
         Buff.num(sigflag, 1),
         encode_tx_version(version),
-        encode_tx_locktime(locktime)
+        encode_tx_locktime(locktime),
     ];
     if (!is_anypay) {
-        const prevouts = input.map(e => get_prevout(e));
+        const prevouts = input.map((e) => get_prevout(e));
         preimage.push(bip341_hash_outpoints(input), bip341_hash_amounts(prevouts), bip341_hash_scripts(prevouts), bip341_hash_sequence(input));
     }
     if ((sigflag & 0x03) < 2 || (sigflag & 0x03) > 3) {
@@ -50,18 +53,19 @@ export function get_taproot_tx_preimage(template, config = {}) {
         preimage.push(encode_txin_txid(txid), encode_txin_vout(vout), encode_vout_value(value), encode_script_data(script_pk), encode_txin_sequence(sequence));
     }
     else {
-        Assert.ok(typeof txindex === 'number');
+        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');
+        Assert.ok(typeof txindex === "number", "txindex required for SIGHASH_SINGLE");
+        Assert.ok(txindex >= 0 && txindex < output.length, `txindex ${txindex} out of bounds for ${output.length} outputs`);
         preimage.push(bip341_hash_output(output[txindex]));
     }
     if (extension !== undefined) {
-        preimage.push(Buff.bytes(extension), Buff.num(key_version), Buff.num(separator_pos, 4, 'le'));
+        preimage.push(Buff.bytes(extension), Buff.num(key_version), Buff.num(separator_pos, 4, "le"));
     }
     return Buff.join(preimage);
 }
@@ -74,13 +78,13 @@ export function bip341_hash_outpoints(vin) {
     return sha256(Buff.join(stack));
 }
 export function bip341_hash_sequence(vin) {
-    return sha256(...vin.map(vin => encode_txin_sequence(vin.sequence)));
+    return sha256(...vin.map((vin) => encode_txin_sequence(vin.sequence)));
 }
 export function bip341_hash_amounts(prevouts) {
-    return sha256(...prevouts.map(prevout => encode_vout_value(prevout.value)));
+    return sha256(...prevouts.map((prevout) => encode_vout_value(prevout.value)));
 }
 export function bip341_hash_scripts(prevouts) {
-    return sha256(...prevouts.map(prevout => encode_script_data(prevout.script_pk)));
+    return sha256(...prevouts.map((prevout) => encode_script_data(prevout.script_pk)));
 }
 export function bip341_hash_outputs(vout) {
     const stack = [];

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

@@ -1,5 +1,5 @@
-import { Buff } from '@vbyte/buff';
-import type { SigHashOptions, TxInput, TxData, TxOutput } from '../../types/index.js';
+import { Buff } from "@vbyte/buff";
+import type { SigHashOptions, TxData, TxInput, TxOutput } from "../../types/index.js";
 export declare function get_prevout(vin: TxInput): TxOutput;
 export declare function parse_txinput(txdata: TxData, config?: SigHashOptions): TxInput;
 export declare function get_annex_data(witness?: string[]): Buff | undefined;

package/dist/lib/sighash/util.js

@@ -1,15 +1,16 @@
-import { Buff } from '@vbyte/buff';
-import { Assert } from '@vbyte/micro-lib';
-import { sha256 } from '@vbyte/micro-lib/hash';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/util";
+import { sha256 } from "@vbyte/crypto/hash";
+import { ValidationError } from "../../error.js";
 export function get_prevout(vin) {
-    Assert.exists(vin.prevout, 'Prevout data missing for input: ' + String(vin.txid));
+    Assert.exists(vin.prevout, `Prevout data missing for input: ${String(vin.txid)}`);
     return vin.prevout;
 }
 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));
+            throw new ValidationError(`input index ${txindex} out of bounds. Transaction has ${txdata.vin.length} inputs (indices 0-${txdata.vin.length - 1})`);
         }
         txinput = txdata.vin.at(txindex);
     }
@@ -22,8 +23,8 @@ export function get_annex_data(witness) {
     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');
+    if (typeof annex === "string" && annex.startsWith("50")) {
+        const bytes = Buff.hex(annex).prefix_varint("be");
         return sha256(bytes);
     }
     return undefined;

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

@@ -1,2 +1,2 @@
-export * from './sign.js';
-export * from './verify.js';
+export * from "./sign.js";
+export * from "./verify.js";

package/dist/lib/signer/index.js

@@ -1,2 +1,2 @@
-export * from './sign.js';
-export * from './verify.js';
+export * from "./sign.js";
+export * from "./verify.js";

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

@@ -1,3 +1,3 @@
-import type { SigHashOptions, TxData } from '../../types/index.js';
+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/signer/sign.js

@@ -1,10 +1,44 @@
-import { Buff } from '@vbyte/buff';
-import { ECC } from '@vbyte/micro-lib';
-import { parse_tx } from '../../lib/tx/parse.js';
-import { SIGHASH_DEFAULT } from '../../const.js';
-import { hash_segwit_tx } from '../../lib/sighash/segwit.js';
-import { hash_taproot_tx } from '../../lib/sighash/taproot.js';
+import { Buff } from "@vbyte/buff";
+import { ECC } from "@vbyte/crypto";
+import { SIGHASH_DEFAULT, SIGHASH_SEGWIT, SIGHASH_TAPROOT } from "../../const.js";
+import { ConfigError, ValidationError } from "../../error.js";
+import { hash_segwit_tx } from "../../lib/sighash/segwit.js";
+import { hash_taproot_tx } from "../../lib/sighash/taproot.js";
+import { parse_tx } from "../../lib/tx/parse.js";
+const SECKEY_REGEX = /^[0-9a-fA-F]{64}$/;
+function validate_seckey(seckey) {
+    if (typeof seckey !== "string") {
+        throw new ValidationError("Secret key must be a string", "seckey");
+    }
+    if (!SECKEY_REGEX.test(seckey)) {
+        throw new ValidationError("Invalid secret key format: expected 32-byte hex string (64 characters)", "seckey");
+    }
+}
+function validate_sighash_options(options, validFlags) {
+    const { sigflag, txindex } = options;
+    if (sigflag !== undefined) {
+        if (typeof sigflag !== "number" || !Number.isInteger(sigflag)) {
+            throw new ConfigError("sigflag must be an integer");
+        }
+        const normalizedFlag = sigflag & 0x7f;
+        const isAnypay = (sigflag & 0x80) === 0x80;
+        const baseFlag = isAnypay ? normalizedFlag | 0x80 : normalizedFlag;
+        if (!validFlags.includes(baseFlag) &&
+            !validFlags.includes(normalizedFlag)) {
+            throw new ConfigError(`Invalid sigflag: ${sigflag}`);
+        }
+    }
+    if (txindex !== undefined) {
+        if (typeof txindex !== "number" ||
+            !Number.isInteger(txindex) ||
+            txindex < 0) {
+            throw new ValidationError("txindex must be a non-negative integer", "txindex");
+        }
+    }
+}
 export function sign_segwit_tx(seckey, txdata, options) {
+    validate_seckey(seckey);
+    validate_sighash_options(options, SIGHASH_SEGWIT);
     const tx = parse_tx(txdata);
     const msg = hash_segwit_tx(tx, options);
     const sig = ECC.sign_ecdsa(seckey, msg).hex;
@@ -12,6 +46,8 @@ export function sign_segwit_tx(seckey, txdata, options) {
     return sig + flag;
 }
 export function sign_taproot_tx(seckey, txdata, options) {
+    validate_seckey(seckey);
+    validate_sighash_options(options, SIGHASH_TAPROOT);
     const tx = parse_tx(txdata);
     const msg = hash_taproot_tx(tx, options);
     const sig = ECC.sign_bip340(seckey, msg).hex;
@@ -19,5 +55,5 @@ export function sign_taproot_tx(seckey, txdata, options) {
     return sig + flag;
 }
 function format_sigflag(flag) {
-    return (flag !== 0) ? Buff.num(flag, 1).hex : '';
+    return flag !== 0 ? Buff.num(flag, 1).hex : "";
 }

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

@@ -1,3 +1,17 @@
-import { Bytes } from '@vbyte/buff';
-import type { SigHashOptions, TxData } from '../../types/index.js';
-export declare function verify_tx(_txdata: TxData | Bytes, _config?: SigHashOptions): boolean;
+import { type Bytes } from "@vbyte/buff";
+import type { SigHashOptions, TxData } from "../../types/index.js";
+export interface VerifyOptions extends SigHashOptions {
+    throws?: boolean;
+}
+export interface VerifyResult {
+    valid: boolean;
+    inputs: InputVerifyResult[];
+    error?: string;
+}
+export interface InputVerifyResult {
+    index: number;
+    valid: boolean;
+    type?: string | null;
+    error?: string;
+}
+export declare function verify_tx(txdata: TxData | Bytes, options?: VerifyOptions): VerifyResult;

package/dist/lib/signer/verify.js

@@ -1,4 +1,233 @@
-export function verify_tx(_txdata, _config = {}) {
-    console.warn('verify_segwit_tx is not implemented');
-    return true;
+import { Buff } from "@vbyte/buff";
+import { ECC } from "@vbyte/crypto";
+import { hash160 } from "@vbyte/crypto/hash";
+import { ValidationError } from "../../error.js";
+import { hash_segwit_tx } from "../../lib/sighash/segwit.js";
+import { hash_taproot_tx } from "../../lib/sighash/taproot.js";
+import { verify_taproot } from "../../lib/taproot/cblock.js";
+import { encode_tapscript } from "../../lib/taproot/encode.js";
+import { parse_tx } from "../../lib/tx/index.js";
+import { parse_witness } from "../../lib/witness/parse.js";
+export function verify_tx(txdata, options = {}) {
+    const { throws = false } = options;
+    const tx = parse_tx(txdata);
+    const inputs = [];
+    let allValid = true;
+    for (let i = 0; i < tx.vin.length; i++) {
+        const vin = tx.vin[i];
+        if (vin.coinbase !== null) {
+            inputs.push({ index: i, valid: true, type: "coinbase" });
+            continue;
+        }
+        const result = verify_input(tx, vin, i, options);
+        inputs.push(result);
+        if (!result.valid) {
+            allValid = false;
+            if (throws) {
+                throw new ValidationError(`Input ${i} verification failed: ${result.error}`, `vin[${i}]`);
+            }
+        }
+    }
+    return {
+        valid: allValid,
+        inputs,
+        error: allValid ? undefined : "One or more inputs failed verification",
+    };
+}
+function verify_input(tx, vin, index, options) {
+    try {
+        const { witness = [] } = vin;
+        if (witness.length === 0) {
+            return { index, valid: true, type: null };
+        }
+        const witnessData = parse_witness(witness.map((e) => Buff.hex(e)));
+        const { type, version } = witnessData;
+        if (type === null || version === null) {
+            return { index, valid: false, type, error: "Unknown witness type" };
+        }
+        const prevout = vin.prevout;
+        if (prevout === null || prevout === undefined) {
+            return { index, valid: false, type, error: "Missing prevout data" };
+        }
+        if (version === 0) {
+            return verify_segwit_input(tx, vin, index, witnessData, options);
+        }
+        else if (version === 1) {
+            return verify_taproot_input(tx, vin, index, witnessData, options);
+        }
+        return {
+            index,
+            valid: false,
+            type,
+            error: `Unsupported witness version: ${version}`,
+        };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        return { index, valid: false, error };
+    }
+}
+function verify_segwit_input(tx, vin, index, witnessData, options) {
+    const { type, params, script } = witnessData;
+    if (params.length < 1) {
+        return { index, valid: false, type, error: "Missing signature in witness" };
+    }
+    const sigHex = params[0];
+    const { signature, sigflag } = parse_ecdsa_signature(sigHex);
+    let pubkey;
+    let hashScript;
+    if (type === "p2wpkh") {
+        if (params.length < 2) {
+            return {
+                index,
+                valid: false,
+                type,
+                error: "Missing pubkey in P2WPKH witness",
+            };
+        }
+        pubkey = params[1];
+        const pkh = hash160(pubkey).hex;
+        hashScript = `76a914${pkh}88ac`;
+    }
+    else if (type === "p2wsh") {
+        if (script === null) {
+            return {
+                index,
+                valid: false,
+                type,
+                error: "Missing script in P2WSH witness",
+            };
+        }
+        hashScript = script;
+        if (params.length >= 2) {
+            pubkey = params[1];
+        }
+        else {
+            return {
+                index,
+                valid: false,
+                type,
+                error: "Missing pubkey in P2WSH witness",
+            };
+        }
+    }
+    else {
+        return {
+            index,
+            valid: false,
+            type,
+            error: `Unexpected segwit type: ${type}`,
+        };
+    }
+    const sighashOptions = {
+        ...options,
+        txindex: index,
+        txinput: vin,
+        pubkey: type === "p2wpkh" ? pubkey : undefined,
+        script: type === "p2wsh" ? hashScript : undefined,
+        sigflag,
+    };
+    const hash = hash_segwit_tx(tx, sighashOptions);
+    const isValid = ECC.verify_ecdsa(signature, hash, pubkey);
+    return {
+        index,
+        valid: isValid,
+        type,
+        error: isValid ? undefined : "Invalid ECDSA signature",
+    };
+}
+function verify_taproot_input(tx, vin, index, witnessData, options) {
+    const { type, params, script, cblock } = witnessData;
+    if (vin.prevout == null) {
+        return {
+            index,
+            valid: false,
+            type,
+            error: "Missing prevout for taproot verification",
+        };
+    }
+    const prevout = vin.prevout;
+    if (params.length < 1) {
+        return { index, valid: false, type, error: "Missing signature in witness" };
+    }
+    const sigHex = params[0];
+    const { signature, sigflag } = parse_schnorr_signature(sigHex);
+    const tapkey = prevout.script_pk.slice(4);
+    let pubkey;
+    let extension;
+    if (type === "p2tr") {
+        pubkey = tapkey;
+    }
+    else if (type === "p2ts") {
+        if (cblock === null || script === null) {
+            return {
+                index,
+                valid: false,
+                type,
+                error: "Missing cblock or script in script-path spend",
+            };
+        }
+        const target = encode_tapscript(script).hex;
+        const pathValid = verify_taproot(tapkey, target, cblock);
+        if (!pathValid) {
+            return {
+                index,
+                valid: false,
+                type,
+                error: "Control block verification failed",
+            };
+        }
+        if (params.length >= 2 && params[1].length === 64) {
+            pubkey = params[1];
+        }
+        else {
+            pubkey = tapkey;
+        }
+        extension = target;
+    }
+    else {
+        return {
+            index,
+            valid: false,
+            type,
+            error: `Unexpected taproot type: ${type}`,
+        };
+    }
+    const sighashOptions = {
+        ...options,
+        txindex: index,
+        txinput: vin,
+        sigflag,
+        extension: extension,
+        script: type === "p2ts" ? (script ?? undefined) : undefined,
+    };
+    const hash = hash_taproot_tx(tx, sighashOptions);
+    const isValid = ECC.verify_bip340(signature, hash, pubkey);
+    return {
+        index,
+        valid: isValid,
+        type,
+        error: isValid ? undefined : "Invalid Schnorr signature",
+    };
+}
+function parse_ecdsa_signature(sigHex) {
+    const sigBytes = Buff.hex(sigHex);
+    const sigflag = sigBytes.at(-1) ?? 0x01;
+    const signature = sigBytes.slice(0, -1).hex;
+    return { signature, sigflag };
+}
+function parse_schnorr_signature(sigHex) {
+    const sigBytes = Buff.hex(sigHex);
+    if (sigBytes.length === 64) {
+        return { signature: sigHex, sigflag: 0x00 };
+    }
+    else if (sigBytes.length === 65) {
+        const sigflag = sigBytes.at(-1) ?? 0x00;
+        if (sigflag === 0x00) {
+            throw new ValidationError("0x00 is not a valid appended sigflag (use 64-byte signature for SIGHASH_DEFAULT)", "sigflag");
+        }
+        const signature = sigBytes.slice(0, 64).hex;
+        return { signature, sigflag };
+    }
+    throw new ValidationError(`Invalid Schnorr signature length: ${sigBytes.length} (expected 64 or 65 bytes)`, "signature");
 }

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

@@ -1,3 +1,3 @@
-import { TaprootConfig, TaprootContext } from '../../types/index.js';
+import type { 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

@@ -1,18 +1,17 @@
-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';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/util";
+import { ECC } from "@vbyte/crypto";
+import { TAPLEAF_DEFAULT_VERSION } from "../../const.js";
+import * as Schema from "../../schema/index.js";
+import { encode_tapbranch, encode_taptweak } from "./encode.js";
+import { parse_cblock, parse_pubkey_parity } from "./parse.js";
+import { merkleize } from "./tree.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;
+    const target = config.target !== undefined ? Buff.bytes(config.target).hex : undefined;
     let path = [], taproot;
     if (leaves.length > 0) {
         const [root, _, proofs] = merkleize(leaves, target);
@@ -23,13 +22,13 @@ export function create_taproot(config) {
         taproot = target;
     }
     const taptweak = encode_taptweak(pubkey, taproot);
-    const twk_key = ECC.tweak_pubkey(pubkey, taptweak, 'ecdsa');
+    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 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));
+        block.push(...path);
     }
     const cblock = Buff.join(block);
     return {
@@ -39,11 +38,11 @@ export function create_taproot(config) {
         taproot: taproot ?? null,
         cblock: cblock.hex,
         tapkey: tapkey.hex,
-        taptweak: taptweak.hex
+        taptweak: taptweak.hex,
     };
 }
 export function verify_taproot(tapkey, target, cblock) {
-    Assert.size(tapkey, 32);
+    Assert.ok(Buff.bytes(tapkey).length === 32, "tapkey must be 32 bytes");
     const { parity, path, int_key } = parse_cblock(cblock);
     const ext_key = Buff.join([parity, tapkey]);
     let branch = Buff.bytes(target).hex;
@@ -51,6 +50,6 @@ export function verify_taproot(tapkey, target, cblock) {
         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);
+    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

@@ -1,4 +1,4 @@
-import { Buff } from '@vbyte/buff';
+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;

package/dist/lib/taproot/encode.js

@@ -1,7 +1,8 @@
-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';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/util";
+import { hash340 } from "@vbyte/crypto/hash";
+import { TAPLEAF_DEFAULT_VERSION } from "../../const.js";
+import { prefix_script_size } from "../../lib/script/index.js";
 const DEFAULT_VERSION = TAPLEAF_DEFAULT_VERSION;
 export function encode_tapscript(script, version = DEFAULT_VERSION) {
     const preimg = prefix_script_size(script);
@@ -9,18 +10,18 @@ export function encode_tapscript(script, version = DEFAULT_VERSION) {
 }
 export function encode_tapleaf(data, version = DEFAULT_VERSION) {
     const vbyte = encode_leaf_version(version);
-    return hash340('TapLeaf', vbyte, data);
+    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);
+    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);
+    Assert.ok(Buff.bytes(pubkey).length === 32, "pubkey must be 32 bytes");
+    return hash340("TapTweak", pubkey, data);
 }

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

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

package/dist/lib/taproot/index.js

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

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

@@ -1,4 +1,4 @@
-import type { ControlBlock } from '../../types/index.js';
+import type { ControlBlock } from "../../types/index.js";
 export declare function parse_taproot_witness(witness: string[]): {
     cblock: ControlBlock;
     params: string[];