@vbyte/btc-dev 1.1.8 → 2.0.0

package/dist/lib/signer/verify.js

@@ -1,4 +1,234 @@
-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/micro-lib";
+import { hash160 } from "@vbyte/micro-lib/hash";
+import { get_lock_script_type } from "../../lib/script/lock.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 Error(`Input ${i} verification failed: ${result.error}`);
+            }
+        }
+    }
+    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" };
+        }
+        const scriptType = get_lock_script_type(prevout.script_pk);
+        if (version === 0) {
+            return verify_segwit_input(tx, vin, index, witnessData, options);
+        }
+        else if (version === 1) {
+            return verify_taproot_input(tx, vin, index, witnessData, scriptType, 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, _scriptType, 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 Error("0x00 is not a valid appended sigflag");
+        }
+        const signature = sigBytes.slice(0, 64).hex;
+        return { signature, sigflag };
+    }
+    throw new Error(`Invalid Schnorr signature length: ${sigBytes.length}`);
 }

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,16 @@
-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, ECC } from "@vbyte/micro-lib";
+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 +21,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,7 +37,7 @@ 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) {
@@ -51,6 +49,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 type { 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,7 @@
-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 { Assert } from "@vbyte/micro-lib";
+import { hash340 } from "@vbyte/micro-lib/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 +9,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);
+    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[];

package/dist/lib/taproot/parse.js

@@ -1,11 +1,11 @@
-import { Buff, Stream } from '@vbyte/buff';
-import { Assert, ECC } from '@vbyte/micro-lib';
-import { parse_witness } from '../../lib/witness/parse.js';
-import { encode_tapbranch, encode_tapscript, encode_taptweak, } from './encode.js';
+import { Buff, Stream } from "@vbyte/buff";
+import { Assert, ECC } from "@vbyte/micro-lib";
+import { parse_witness } from "../../lib/witness/parse.js";
+import { encode_tapbranch, encode_tapscript, encode_taptweak, } from "./encode.js";
 export function parse_taproot_witness(witness) {
     const { cblock, params, script } = parse_witness(witness);
-    Assert.exists(cblock, 'cblock is null');
-    Assert.exists(script, 'script is null');
+    Assert.exists(cblock, "cblock is null");
+    Assert.exists(script, "script is null");
     const cblk = parse_cblock(cblock);
     const target = encode_tapscript(script, cblk.version);
     let branch = target.hex;
@@ -13,8 +13,8 @@ export function parse_taproot_witness(witness) {
         branch = encode_tapbranch(branch, leaf).hex;
     }
     const tweak = encode_taptweak(cblk.int_key, branch);
-    const tapkey = ECC.tweak_pubkey(cblk.int_key, tweak, 'bip340');
-    params.map(e => Buff.bytes(e).hex);
+    const tapkey = ECC.tweak_pubkey(cblk.int_key, tweak, "bip340");
+    params.map((e) => Buff.bytes(e).hex);
     return { cblock: cblk, params, script, tapkey: tapkey.hex, tweak: tweak.hex };
 }
 export function parse_cblock(cblock) {
@@ -27,21 +27,19 @@ export function parse_cblock(cblock) {
         path.push(buffer.read(32).hex);
     }
     if (buffer.size !== 0) {
-        throw new Error('Non-empty buffer on control block: ' + String(buffer));
+        throw new Error(`Non-empty buffer on control block: ${String(buffer)}`);
     }
     return { int_key, path, parity, version };
 }
 export function parse_cblock_parity(cbits) {
-    return (cbits % 2 === 0)
-        ? [cbits - 0, 0x02]
-        : [cbits - 1, 0x03];
+    return cbits % 2 === 0 ? [cbits - 0, 0x02] : [cbits - 1, 0x03];
 }
 export function parse_pubkey_parity(pubkey) {
-    Assert.size(pubkey, 33, 'invalid pubkey size');
+    Assert.size(pubkey, 33, "invalid pubkey size");
     const [parity] = Buff.bytes(pubkey);
     if (parity === 0x02)
         return 0;
     if (parity === 0x03)
         return 1;
-    throw new Error('Invalid parity bit: ' + String(parity));
+    throw new Error(`Invalid parity bit: ${String(parity)}`);
 }

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

@@ -1,3 +1,3 @@
-import type { TapTree, MerkleProof } from '../../types/index.js';
+import type { MerkleProof, TapTree } from "../../types/index.js";
 export declare function get_merkle_root(leaves: TapTree): string;
-export declare function merkleize(taptree: TapTree, target?: string, path?: string[]): MerkleProof;
+export declare function merkleize(taptree: TapTree, target?: string, path?: string[], depth?: number): MerkleProof;

package/dist/lib/taproot/tree.js

@@ -1,18 +1,22 @@
-import { Buff } from '@vbyte/buff';
-import { encode_tapbranch } from './encode.js';
+import { Buff } from "@vbyte/buff";
+import { encode_tapbranch } from "./encode.js";
+const MAX_TAPROOT_DEPTH = 128;
 export function get_merkle_root(leaves) {
     return merkleize(leaves)[0];
 }
-export function merkleize(taptree, target, path = []) {
+export function merkleize(taptree, target, path = [], depth = 0) {
+    if (depth > MAX_TAPROOT_DEPTH) {
+        throw new Error(`Taproot tree depth ${depth} exceeds maximum ${MAX_TAPROOT_DEPTH}`);
+    }
     const leaves = [];
     const tree = [];
     if (taptree.length < 1) {
-        throw new Error('Tree is empty!');
+        throw new Error("Tree is empty!");
     }
     for (let i = 0; i < taptree.length; i++) {
         const bytes = taptree[i];
         if (Array.isArray(bytes)) {
-            let [tapleaf, new_target, branches] = merkleize(bytes, target);
+            const [tapleaf, new_target, branches] = merkleize(bytes, target, [], depth + 1);
             target = new_target;
             leaves.push(tapleaf);
             for (const branch of branches) {
@@ -34,7 +38,7 @@ export function merkleize(taptree, target, path = []) {
     for (let i = 0; i < leaves.length - 1; i += 2) {
         const branch = encode_tapbranch(leaves[i], leaves[i + 1]).hex;
         tree.push(branch);
-        if (typeof target === 'string') {
+        if (typeof target === "string") {
             if (target === leaves[i]) {
                 path.push(leaves[i + 1]);
                 target = branch;
@@ -45,5 +49,5 @@ export function merkleize(taptree, target, path = []) {
             }
         }
     }
-    return merkleize(tree, target, path);
+    return merkleize(tree, target, path, depth + 1);
 }

package/dist/lib/tx/create.d.ts

@@ -1,4 +1,4 @@
-import type { TxData, TxInput, TxOutput, TxTemplate, TxSpendInput, TxCoinbaseInput, TxOutputTemplate, TxVirtualInput, TxInputTemplate } from '../../types/index.js';
+import type { TxCoinbaseInput, TxData, TxInput, TxInputTemplate, TxOutput, TxOutputTemplate, TxSpendInput, TxTemplate, TxVirtualInput } from "../../types/index.js";
 export declare function create_coinbase_input(config: TxInputTemplate): TxCoinbaseInput;
 export declare function create_virtual_input(config: TxInputTemplate): TxVirtualInput;
 export declare function create_spend_input(config: TxInputTemplate): TxSpendInput;

package/dist/lib/tx/create.js

@@ -1,28 +1,44 @@
-import { Assert } from '@vbyte/micro-lib';
-import { COINBASE, DEFAULT } from '../../const.js';
-import { normalize_prevout, normalize_sequence, normalize_value } from './util.js';
-import { assert_tx_template, assert_vin_template, assert_vout_template } from './validate.js';
+import { Assert } from "@vbyte/micro-lib";
+import { COINBASE, DEFAULT } from "../../const.js";
+import { normalize_prevout, normalize_sequence, normalize_value, } from "./util.js";
+import { assert_tx_template, assert_vin_template, assert_vout_template, } from "./validate.js";
 export function create_coinbase_input(config) {
     assert_vin_template(config);
-    Assert.exists(config.coinbase, 'coinbase is required');
+    Assert.exists(config.coinbase, "coinbase is required");
     const txid = COINBASE.TXID;
     const vout = COINBASE.VOUT;
     const coinbase = config.coinbase;
     const witness = config.witness ?? [];
     const sequence = normalize_sequence(config.sequence);
-    return { coinbase, prevout: null, script_sig: null, sequence, witness, txid, vout };
+    return {
+        coinbase,
+        prevout: null,
+        script_sig: null,
+        sequence,
+        witness,
+        txid,
+        vout,
+    };
 }
 export function create_virtual_input(config) {
     assert_vin_template(config);
-    Assert.is_empty(config.coinbase, 'coinbase is not allowed');
-    Assert.is_empty(config.prevout, 'prevout is not allowed');
+    Assert.is_empty(config.coinbase, "coinbase is not allowed");
+    Assert.is_empty(config.prevout, "prevout is not allowed");
     const { txid, vout, script_sig = null, witness = [] } = config;
     const sequence = normalize_sequence(config.sequence);
-    return { txid, vout, coinbase: null, prevout: null, script_sig, sequence, witness };
+    return {
+        txid,
+        vout,
+        coinbase: null,
+        prevout: null,
+        script_sig,
+        sequence,
+        witness,
+    };
 }
 export function create_spend_input(config) {
     assert_vin_template(config);
-    Assert.exists(config.prevout, 'prevout is required');
+    Assert.exists(config.prevout, "prevout is required");
     const { txid, vout, script_sig = null, witness = [] } = config;
     const prevout = normalize_prevout(config.prevout);
     const sequence = normalize_sequence(config.sequence);
@@ -46,7 +62,7 @@ export function create_tx(config) {
     const { vin = [], vout = [] } = config ?? { vin: [], vout: [] };
     const locktime = config.locktime ?? DEFAULT.LOCKTIME;
     const version = config.version ?? DEFAULT.VERSION;
-    const inputs = vin.map(txin => create_tx_input(txin));
-    const outputs = vout.map(txout => create_tx_output(txout));
+    const inputs = vin.map((txin) => create_tx_input(txin));
+    const outputs = vout.map((txout) => create_tx_output(txout));
     return { locktime, vin: inputs, vout: outputs, version };
 }

package/dist/lib/tx/decode.d.ts

@@ -1,4 +1,4 @@
-import { Stream } from '@vbyte/buff';
-import { TxDecodedData } from '../../types/index.js';
+import { Stream } from "@vbyte/buff";
+import type { TxDecodedData } from "../../types/index.js";
 export declare function decode_tx(txdata: string | Uint8Array, use_segwit?: boolean): TxDecodedData;
 export declare function read_payload(stream: Stream): string | null;