@vbyte/btc-dev 2.0.0 → 2.1.0

package/dist/lib/address/p2wpkh.js

@@ -1,6 +1,6 @@
 import { Buff } from "@vbyte/buff";
-import { Assert } from "@vbyte/micro-lib";
-import { hash160 } from "@vbyte/micro-lib/hash";
+import { Assert } from "@vbyte/util";
+import { hash160 } from "@vbyte/crypto/hash";
 import { LOCK_SCRIPT_TYPE } from "../../const.js";
 import { is_p2wpkh_script } from "../../lib/script/lock.js";
 import { encode_address } from "./encode.js";
@@ -21,7 +21,7 @@ function create_p2wpkh_address(pubkey, network = "main") {
 }
 function create_p2wpkh_script(pubkey) {
     const bytes = Buff.bytes(pubkey);
-    Assert.size(bytes, 33, "invalid pubkey size");
+    Assert.ok(bytes.length === 33, "invalid pubkey size");
     const hash = hash160(bytes);
     return encode_p2wpkh_script(hash);
 }
@@ -32,7 +32,7 @@ function encode_p2wpkh_address(script_pk, network = "main") {
     const pk_hash = decode_p2wpkh_script(script_pk);
     const config = get_address_config(network, ADDRESS_TYPE);
     Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE} on ${network}`);
-    Assert.size(pk_hash, config.size, `invalid payload size: ${pk_hash.length} !== ${config.size}`);
+    Assert.ok(pk_hash.length === config.size, `invalid payload size: ${pk_hash.length} !== ${config.size}`);
     return encode_address({
         data: pk_hash,
         format: "bech32",

package/dist/lib/address/p2wsh.js

@@ -1,6 +1,6 @@
 import { Buff } from "@vbyte/buff";
-import { Assert } from "@vbyte/micro-lib";
-import { sha256 } from "@vbyte/micro-lib/hash";
+import { Assert } from "@vbyte/util";
+import { sha256 } from "@vbyte/crypto/hash";
 import { LOCK_SCRIPT_TYPE } from "../../const.js";
 import { is_p2wsh_script } from "../../lib/script/lock.js";
 import { encode_address } from "./encode.js";
@@ -31,7 +31,7 @@ function encode_p2wsh_address(script_pk, network = "main") {
     const script_hash = decode_p2wsh_script(script_pk);
     const config = get_address_config(network, ADDRESS_TYPE);
     Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE} on ${network}`);
-    Assert.size(script_hash, config.size, `invalid payload size: ${script_hash.length} !== ${config.size}`);
+    Assert.ok(script_hash.length === config.size, `invalid payload size: ${script_hash.length} !== ${config.size}`);
     return encode_address({
         data: script_hash,
         format: "bech32",

package/dist/lib/address/util.js

@@ -1,4 +1,5 @@
 import { Buff } from "@vbyte/buff";
+import { ConfigError } from "../../error.js";
 import { decode_address } from "./encode.js";
 import { get_address_script } from "./script.js";
 const CONFIG_TABLE = [
@@ -49,5 +50,6 @@ export function get_address_info(address) {
         const script = get_address_script(data, type);
         return { data, script, type, prefix, network, size, format, version };
     }
-    throw new Error("address configuration is invalid");
+    throw new ConfigError(`unrecognized address configuration: format=${dec.format}, size=${dec.data.length}, version=${dec.version}. ` +
+        `Supported formats: base58 (p2pkh, p2sh), bech32 (p2wpkh, p2wsh), bech32m (p2tr)`);
 }

package/dist/lib/meta/locktime.js

@@ -1,4 +1,5 @@
-import { Assert } from "@vbyte/micro-lib";
+import { Assert } from "@vbyte/util";
+import { ConfigError } from "../../error.js";
 const LOCKTIME_THRESHOLD = 500000000;
 export var LocktimeField;
 (function (LocktimeField) {
@@ -15,7 +16,7 @@ export function encode_locktime(locktime) {
             Assert.ok(locktime.height < LOCKTIME_THRESHOLD, "invalid block height");
             return locktime.height;
         default:
-            throw new Error("Invalid locktime type");
+            throw new ConfigError(`Invalid locktime type: expected 'timelock' or 'heightlock'`);
     }
 }
 export function decode_locktime(locktime) {

package/dist/lib/meta/ref.js

@@ -1,3 +1,4 @@
+import { ValidationError } from "../../error.js";
 export var RefPointer;
 (function (RefPointer) {
     RefPointer.outpoint = {
@@ -32,7 +33,7 @@ function verify_inscription_id(inscription_id) {
 }
 function assert_inscription_id(inscription_id) {
     if (!verify_inscription_id(inscription_id)) {
-        throw new Error(`invalid inscription id: ${inscription_id}`);
+        throw new ValidationError(`invalid inscription id: "${inscription_id}". Expected format: <64-char-txid>i<index> (e.g., "abc123...i0")`);
     }
 }
 function encode_rune_id(block_height, block_index) {
@@ -51,7 +52,7 @@ function verify_rune_id(rune_id) {
 }
 function assert_rune_id(rune_id) {
     if (!verify_rune_id(rune_id)) {
-        throw new Error(`invalid rune id: ${rune_id}`);
+        throw new ValidationError(`invalid rune id: "${rune_id}". Expected format: <block_height>:<block_index> (e.g., "840000:1")`);
     }
 }
 function encode_outpoint(txid, vout) {
@@ -67,6 +68,6 @@ function verify_outpoint(outpoint) {
 }
 function assert_outpoint(outpoint) {
     if (!verify_outpoint(outpoint)) {
-        throw new Error(`invalid outpoint: ${outpoint}`);
+        throw new ValidationError(`invalid outpoint: "${outpoint}". Expected format: <64-char-txid>:<vout> (e.g., "abc123...:0")`);
     }
 }

package/dist/lib/meta/scribe.js

@@ -1,5 +1,6 @@
 import { Buff, Stream } from "@vbyte/buff";
-import { Assert } from "@vbyte/micro-lib";
+import { Assert } from "@vbyte/util";
+import { ValidationError } from "../../error.js";
 import { decode_script } from "../../lib/script/decode.js";
 import { encode_script } from "../../lib/script/encode.js";
 const _0n = BigInt(0);
@@ -59,13 +60,14 @@ function parse_envelopes(script) {
     Assert.ok(start_idx !== -1, "inscription envelope not found");
     const envelopes = [];
     for (let idx = start_idx; idx < words.length; idx++) {
+        Assert.ok(idx + 2 < words.length, "incomplete envelope: missing OP_IF or magic bytes");
         Assert.ok(words[idx + 1] === "OP_IF", "OP_IF missing from envelope");
         Assert.ok(words[idx + 2] === "6f7264", "magic bytes missing from envelope");
-        const stop_idx = words.indexOf("OP_ENDIF");
-        Assert.ok(stop_idx !== -1, "inscription envelope missing END_IF statement");
+        const stop_idx = words.indexOf("OP_ENDIF", idx);
+        Assert.ok(stop_idx !== -1, "inscription envelope missing OP_ENDIF statement");
         const env = words.slice(idx + 3, stop_idx);
         envelopes.push(env);
-        idx += stop_idx;
+        idx = stop_idx;
     }
     return envelopes;
 }
@@ -111,6 +113,19 @@ function parse_record(envelope) {
 function decode_bytes(bytes) {
     return Buff.bytes(bytes).hex;
 }
+function normalize_script_word(word) {
+    if (typeof word === "string" && word.startsWith("OP_")) {
+        if (word === "OP_0")
+            return Buff.num(0).hex;
+        const match = word.match(/^OP_(\d+)$/);
+        if (match) {
+            const num = parseInt(match[1], 10);
+            if (num >= 1 && num <= 16)
+                return Buff.num(num).hex;
+        }
+    }
+    return word;
+}
 function encode_id(identifier) {
     Assert.ok(identifier.includes("i"), "identifier must include an index");
     const parts = identifier.split("i");
@@ -121,6 +136,9 @@ function encode_id(identifier) {
 }
 function decode_id(identifier) {
     const bytes = Buff.bytes(identifier);
+    if (bytes.length === 32) {
+        return `${bytes.reverse().hex}i0`;
+    }
     const idx = bytes.at(-1) ?? 0;
     const txid = bytes.slice(0, -1).reverse().hex;
     return `${txid}i${String(idx)}`;
@@ -129,7 +147,7 @@ function encode_pointer(pointer) {
     return Buff.num(pointer).reverse().hex;
 }
 function decode_pointer(bytes) {
-    return Buff.bytes(bytes).reverse().num;
+    return Buff.bytes(normalize_script_word(bytes)).reverse().num;
 }
 function encode_label(label) {
     return Buff.str(label).hex;
@@ -165,13 +183,15 @@ function encode_rune_label(label) {
             big = big * _26n + BigInt(char.charCodeAt(0) - ("A".charCodeAt(0) - 1));
         }
         else {
+            throw new ValidationError(`invalid character in rune label: '${char}' (only A-Z allowed)`, "label");
         }
     }
     big = big - _1n;
     return Buff.big(big).reverse().hex;
 }
 function decode_rune_label(label) {
-    let big = Buff.bytes(label).reverse().big;
+    const normalized = normalize_script_word(label);
+    let big = Buff.bytes(normalized).reverse().big;
     big = big + _1n;
     let result = "";
     while (big > _0n) {

package/dist/lib/meta/sequence.js

@@ -1,3 +1,4 @@
+import { ValidationError } from "../../error.js";
 const TIMELOCK_DISABLE = 0x80000000;
 const TIMELOCK_TYPE = 0x00400000;
 const TIMELOCK_VALUE_MASK = 0x0000ffff;
@@ -17,7 +18,7 @@ export function encode_sequence(data) {
         const stamp = parse_stamp(data.stamp);
         return (TIMELOCK_TYPE | (stamp & TIMELOCK_VALUE_MASK)) >>> 0;
     }
-    throw new Error(`invalid timelock mode: ${data.mode}`);
+    throw new ValidationError(`invalid timelock mode: "${data.mode}". Valid modes are "height" or "stamp"`);
 }
 export function decode_sequence(sequence) {
     const seq = parse_sequence(sequence);
@@ -27,13 +28,13 @@ export function decode_sequence(sequence) {
     if (seq & TIMELOCK_TYPE) {
         const stamp = value * TIMELOCK_GRANULARITY;
         if (stamp > 0xffffffff) {
-            throw new Error("Decoded timestamp exceeds 32-bit limit");
+            throw new ValidationError(`decoded timestamp ${stamp} exceeds 32-bit limit (max: ${0xffffffff})`);
         }
         return { mode: "stamp", stamp };
     }
     else {
         if (value > TIMELOCK_VALUE_MAX) {
-            throw new Error("Decoded height exceeds maximum");
+            throw new ValidationError(`decoded height ${value} exceeds maximum (${TIMELOCK_VALUE_MAX})`);
         }
         return { mode: "height", height: value };
     }
@@ -41,17 +42,17 @@ export function decode_sequence(sequence) {
 function parse_sequence(sequence) {
     const seq = typeof sequence === "string" ? parseInt(sequence, 16) : sequence;
     if (!Number.isInteger(seq) || seq < 0 || seq > 0xffffffff) {
-        throw new Error(`invalid sequence value: ${seq}`);
+        throw new ValidationError(`invalid sequence value: ${seq}. Must be an integer between 0 and 0xffffffff`);
     }
     return seq;
 }
 function parse_stamp(stamp) {
     if (stamp === undefined || !Number.isInteger(stamp)) {
-        throw new Error(`timestamp must be a number`);
+        throw new ValidationError(`timestamp must be an integer, got: ${stamp}`);
     }
     const ts = Math.floor(stamp / TIMELOCK_GRANULARITY);
     if (!Number.isInteger(ts) || ts < 0 || ts > TIMELOCK_VALUE_MAX) {
-        throw new Error(`timelock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX} (in 512-second increments)`);
+        throw new ValidationError(`timelock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX} (in 512-second increments)`);
     }
     return ts;
 }
@@ -60,7 +61,7 @@ function parse_height(height) {
         !Number.isInteger(height) ||
         height < 0 ||
         height > TIMELOCK_VALUE_MAX) {
-        throw new Error(`Heightlock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX}`);
+        throw new ValidationError(`heightlock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX}, got: ${height}`);
     }
     return height;
 }

package/dist/lib/script/decode.js

@@ -1,4 +1,5 @@
 import { Buff, Stream } from "@vbyte/buff";
+import { DecodingError } from "../../error.js";
 import { get_op_code, get_op_type, is_valid_op } from "./words.js";
 export function parse_script(script) {
     const bytes = Buff.bytes(script);
@@ -25,7 +26,7 @@ export function decode_script(script) {
                     stack.push(stream.read(word).hex);
                 }
                 catch {
-                    throw new Error(`Malformed script: varint push at position ${count - 1} requires ${word} bytes but stream exhausted`);
+                    throw new DecodingError(`Malformed script: varint push at position ${count - 1} requires ${word} bytes but stream exhausted`, count - 1);
                 }
                 count += word;
                 break;
@@ -34,13 +35,13 @@ export function decode_script(script) {
                     word_size = stream.read(1).reverse().num;
                 }
                 catch {
-                    throw new Error(`Malformed script: PUSHDATA1 at position ${count - 1} missing size byte`);
+                    throw new DecodingError(`Malformed script: PUSHDATA1 at position ${count - 1} missing size byte`, count - 1);
                 }
                 try {
                     stack.push(stream.read(word_size).hex);
                 }
                 catch {
-                    throw new Error(`Malformed script: PUSHDATA1 at position ${count - 1} requires ${word_size} bytes but stream exhausted`);
+                    throw new DecodingError(`Malformed script: PUSHDATA1 at position ${count - 1} requires ${word_size} bytes but stream exhausted`, count - 1);
                 }
                 count += word_size + 1;
                 break;
@@ -49,13 +50,13 @@ export function decode_script(script) {
                     word_size = stream.read(2).reverse().num;
                 }
                 catch {
-                    throw new Error(`Malformed script: PUSHDATA2 at position ${count - 1} missing size bytes`);
+                    throw new DecodingError(`Malformed script: PUSHDATA2 at position ${count - 1} missing size bytes`, count - 1);
                 }
                 try {
                     stack.push(stream.read(word_size).hex);
                 }
                 catch {
-                    throw new Error(`Malformed script: PUSHDATA2 at position ${count - 1} requires ${word_size} bytes but stream exhausted`);
+                    throw new DecodingError(`Malformed script: PUSHDATA2 at position ${count - 1} requires ${word_size} bytes but stream exhausted`, count - 1);
                 }
                 count += word_size + 2;
                 break;
@@ -64,24 +65,24 @@ export function decode_script(script) {
                     word_size = stream.read(4).reverse().num;
                 }
                 catch {
-                    throw new Error(`Malformed script: PUSHDATA4 at position ${count - 1} missing size bytes`);
+                    throw new DecodingError(`Malformed script: PUSHDATA4 at position ${count - 1} missing size bytes`, count - 1);
                 }
                 try {
                     stack.push(stream.read(word_size).hex);
                 }
                 catch {
-                    throw new Error(`Malformed script: PUSHDATA4 at position ${count - 1} requires ${word_size} bytes but stream exhausted`);
+                    throw new DecodingError(`Malformed script: PUSHDATA4 at position ${count - 1} requires ${word_size} bytes but stream exhausted`, count - 1);
                 }
                 count += word_size + 4;
                 break;
             case "opcode":
                 if (!is_valid_op(word)) {
-                    throw new Error(`Invalid OPCODE: ${word}`);
+                    throw new DecodingError(`Invalid OPCODE: ${word}`, count - 1);
                 }
                 stack.push(get_op_code(word));
                 break;
             default:
-                throw new Error(`Word type undefined: ${word}`);
+                throw new DecodingError(`Word type undefined: ${word}`, count - 1);
         }
     }
     return stack;

package/dist/lib/script/encode.js

@@ -1,5 +1,6 @@
 import { Buff, Stream } from "@vbyte/buff";
 import { MAX_SCRIPT_SIZE, OP_1_OFFSET } from "../../const.js";
+import { ValidationError } from "../../error.js";
 import { get_asm_code } from "./words.js";
 const MAX_WORD_SIZE = 520;
 export function encode_script(words, varint = false) {
@@ -11,7 +12,7 @@ export function encode_script(words, varint = false) {
     }
     const buffer = Buff.join(bytes);
     if (buffer.length > MAX_SCRIPT_SIZE) {
-        throw new Error(`script size ${buffer.length} exceeds consensus limit of ${MAX_SCRIPT_SIZE} bytes`);
+        throw new ValidationError(`script size ${buffer.length} exceeds consensus limit of ${MAX_SCRIPT_SIZE} bytes`);
     }
     return varint
         ? buffer.prepend(Buff.create_varint(buffer.length, "le"))
@@ -38,7 +39,7 @@ export function encode_script_word(word) {
         buff = new Buff(word);
     }
     else {
-        throw new Error(`invalid word type:${typeof word}`);
+        throw new ValidationError(`invalid script word type: ${typeof word}. Expected string, number, or Uint8Array`);
     }
     if (buff.length === 1 && buff[0] <= 16) {
         if (buff[0] !== 0)
@@ -79,6 +80,6 @@ export function get_size_varint(size) {
         case size >= 0x100 && size <= MAX_WORD_SIZE:
             return Buff.join([OP_PUSHDATA2, Buff.num(size, 2, "le")]);
         default:
-            throw new Error(`Invalid word size:${size.toString()}`);
+            throw new ValidationError(`invalid script word size: ${size}. Maximum allowed is ${MAX_WORD_SIZE} bytes`);
     }
 }

package/dist/lib/script/words.js

@@ -1,3 +1,4 @@
+import { ValidationError } from "../../error.js";
 export const OPCODE_MAP = {
     OP_0: 0x00,
     OP_PUSHDATA1: 0x4c,
@@ -118,14 +119,14 @@ export function get_op_code(num) {
         if (v === num)
             return k;
     }
-    throw new Error(`OPCODE not found:${String(num)}`);
+    throw new ValidationError(`opcode not found for value: ${num} (0x${num.toString(16)}). Valid range is 0x00-0xba`);
 }
 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}`);
+    throw new ValidationError(`opcode not found: "${string}". Valid opcodes start with "OP_" (e.g., OP_DUP, OP_CHECKSIG)`);
 }
 export function get_op_type(word) {
     switch (true) {
@@ -142,7 +143,7 @@ export function get_op_type(word) {
         case word <= 254:
             return "opcode";
         default:
-            throw new Error(`Invalid word range: ${word}`);
+            throw new ValidationError(`invalid word value: ${word}. Expected 0-254`);
     }
 }
 export function is_valid_op(word) {

package/dist/lib/sighash/segwit.js

@@ -1,7 +1,8 @@
 import { Buff } from "@vbyte/buff";
-import { Assert } from "@vbyte/micro-lib";
-import { hash160, hash256 } from "@vbyte/micro-lib/hash";
+import { Assert } from "@vbyte/util";
+import { hash160, hash256 } from "@vbyte/crypto/hash";
 import * as CONST from "../../const.js";
+import { ValidationError } from "../../error.js";
 import { decode_script, prefix_script_size } from "../../lib/script/index.js";
 import { encode_tx_locktime, encode_tx_version, encode_txin_sequence, encode_txin_txid, encode_txin_vout, encode_vout_value, parse_tx, } from "../../lib/tx/index.js";
 import { parse_txinput } from "./util.js";
@@ -11,14 +12,16 @@ export function hash_segwit_tx(txdata, options = {}) {
     const is_anypay = (sigflag & 0x80) === 0x80;
     const flag = sigflag % 0x80;
     if (!CONST.SIGHASH_SEGWIT.includes(flag)) {
-        throw new Error(`Invalid hash type: ${String(sigflag)}`);
+        throw new ValidationError(`invalid sighash type: 0x${sigflag.toString(16)}. ` +
+            `Valid values: SIGHASH_ALL (0x01), SIGHASH_NONE (0x02), SIGHASH_SINGLE (0x03), ` +
+            `or combined with ANYONECANPAY (0x81, 0x82, 0x83)`);
     }
     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!");
+        throw new ValidationError("Prevout value is required for segwit sighash calculation", "prevout.value");
     }
     let { pubkey, script } = options;
     if (script === undefined && pubkey !== undefined) {
@@ -26,10 +29,10 @@ export function hash_segwit_tx(txdata, options = {}) {
         script = `76a914${String(pkhash)}88ac`;
     }
     if (script === undefined) {
-        throw new Error("No pubkey / script has been set!");
+        throw new ValidationError("Either pubkey or script must be provided for segwit sighash", "pubkey/script");
     }
     if (decode_script(script).includes("OP_CODESEPARATOR")) {
-        throw new Error("This library does not currently support the use of OP_CODESEPARATOR in segwit scripts.");
+        throw new ValidationError("OP_CODESEPARATOR is not supported in segwit scripts", "script");
     }
     const sighash = [
         encode_tx_version(version),

package/dist/lib/sighash/taproot.js

@@ -1,7 +1,8 @@
 import { Buff } from "@vbyte/buff";
-import { Assert } from "@vbyte/micro-lib";
-import { hash340, sha256 } from "@vbyte/micro-lib/hash";
+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";
@@ -17,10 +18,12 @@ export function get_taproot_tx_preimage(template, config = {}) {
     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) {

package/dist/lib/sighash/util.js

@@ -1,6 +1,7 @@
 import { Buff } from "@vbyte/buff";
-import { Assert } from "@vbyte/micro-lib";
-import { sha256 } from "@vbyte/micro-lib/hash";
+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)}`);
     return vin.prevout;
@@ -9,7 +10,7 @@ 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);
     }

package/dist/lib/signer/sign.js

@@ -1,37 +1,38 @@
 import { Buff } from "@vbyte/buff";
-import { ECC } from "@vbyte/micro-lib";
+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 Error("Secret key must be a string");
+        throw new ValidationError("Secret key must be a string", "seckey");
     }
     if (!SECKEY_REGEX.test(seckey)) {
-        throw new Error("Invalid secret key format: expected 32-byte hex string (64 characters)");
+        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 Error("sigflag must be an integer");
+            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 Error(`Invalid sigflag: ${sigflag}`);
+            throw new ConfigError(`Invalid sigflag: ${sigflag}`);
         }
     }
     if (txindex !== undefined) {
         if (typeof txindex !== "number" ||
             !Number.isInteger(txindex) ||
             txindex < 0) {
-            throw new Error("txindex must be a non-negative integer");
+            throw new ValidationError("txindex must be a non-negative integer", "txindex");
         }
     }
 }

package/dist/lib/signer/verify.js

@@ -1,7 +1,7 @@
 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 { 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";
@@ -24,7 +24,7 @@ export function verify_tx(txdata, options = {}) {
         if (!result.valid) {
             allValid = false;
             if (throws) {
-                throw new Error(`Input ${i} verification failed: ${result.error}`);
+                throw new ValidationError(`Input ${i} verification failed: ${result.error}`, `vin[${i}]`);
             }
         }
     }
@@ -49,12 +49,11 @@ function verify_input(tx, vin, index, options) {
         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 verify_taproot_input(tx, vin, index, witnessData, options);
         }
         return {
             index,
@@ -137,7 +136,7 @@ function verify_segwit_input(tx, vin, index, witnessData, options) {
         error: isValid ? undefined : "Invalid ECDSA signature",
     };
 }
-function verify_taproot_input(tx, vin, index, witnessData, _scriptType, options) {
+function verify_taproot_input(tx, vin, index, witnessData, options) {
     const { type, params, script, cblock } = witnessData;
     if (vin.prevout == null) {
         return {
@@ -225,10 +224,10 @@ function parse_schnorr_signature(sigHex) {
     else if (sigBytes.length === 65) {
         const sigflag = sigBytes.at(-1) ?? 0x00;
         if (sigflag === 0x00) {
-            throw new Error("0x00 is not a valid appended sigflag");
+            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 Error(`Invalid Schnorr signature length: ${sigBytes.length}`);
+    throw new ValidationError(`Invalid Schnorr signature length: ${sigBytes.length} (expected 64 or 65 bytes)`, "signature");
 }

package/dist/lib/taproot/cblock.js

@@ -1,5 +1,6 @@
 import { Buff } from "@vbyte/buff";
-import { Assert, ECC } from "@vbyte/micro-lib";
+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";
@@ -41,7 +42,7 @@ export function create_taproot(config) {
     };
 }
 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;

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

@@ -1,4 +1,4 @@
-import type { 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,5 +1,6 @@
-import { Assert } from "@vbyte/micro-lib";
-import { hash340 } from "@vbyte/micro-lib/hash";
+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;
@@ -21,6 +22,6 @@ export function encode_leaf_version(version = 0xc0) {
     return version & 0xfe;
 }
 export function encode_taptweak(pubkey, data = new Uint8Array()) {
-    Assert.size(pubkey, 32);
+    Assert.ok(Buff.bytes(pubkey).length === 32, "pubkey must be 32 bytes");
     return hash340("TapTweak", pubkey, data);
 }