@vbyte/btc-dev 2.0.0 → 2.1.0

package/dist/lib/taproot/parse.js

@@ -1,5 +1,7 @@
 import { Buff, Stream } from "@vbyte/buff";
-import { Assert, ECC } from "@vbyte/micro-lib";
+import { Assert } from "@vbyte/util";
+import { ECC } from "@vbyte/crypto";
+import { DecodingError, ValidationError } from "../../error.js";
 import { parse_witness } from "../../lib/witness/parse.js";
 import { encode_tapbranch, encode_tapscript, encode_taptweak, } from "./encode.js";
 export function parse_taproot_witness(witness) {
@@ -14,8 +16,8 @@ export function parse_taproot_witness(witness) {
     }
     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);
-    return { cblock: cblk, params, script, tapkey: tapkey.hex, tweak: tweak.hex };
+    const hexParams = params.map((e) => Buff.bytes(e).hex);
+    return { cblock: cblk, params: hexParams, script, tapkey: tapkey.hex, tweak: tweak.hex };
 }
 export function parse_cblock(cblock) {
     const buffer = new Stream(cblock);
@@ -27,19 +29,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 DecodingError(`control block has ${buffer.size} extra bytes. Expected: 33 + (32 * path_length) bytes`);
     }
     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, 0x02] : [cbits - 1, 0x03];
 }
 export function parse_pubkey_parity(pubkey) {
-    Assert.size(pubkey, 33, "invalid pubkey size");
+    Assert.ok(Buff.bytes(pubkey).length === 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 ValidationError(`invalid pubkey parity prefix: 0x${parity.toString(16)}. Expected 0x02 (even) or 0x03 (odd)`);
 }

package/dist/lib/taproot/tree.js

@@ -1,4 +1,5 @@
 import { Buff } from "@vbyte/buff";
+import { ValidationError } from "../../error.js";
 import { encode_tapbranch } from "./encode.js";
 const MAX_TAPROOT_DEPTH = 128;
 export function get_merkle_root(leaves) {
@@ -6,12 +7,12 @@ export function get_merkle_root(leaves) {
 }
 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}`);
+        throw new ValidationError(`Taproot tree depth ${depth} exceeds maximum ${MAX_TAPROOT_DEPTH}`, "depth");
     }
     const leaves = [];
     const tree = [];
     if (taptree.length < 1) {
-        throw new Error("Tree is empty!");
+        throw new ValidationError("Taproot tree cannot be empty", "taptree");
     }
     for (let i = 0; i < taptree.length; i++) {
         const bytes = taptree[i];

package/dist/lib/tx/create.js

@@ -1,4 +1,4 @@
-import { Assert } from "@vbyte/micro-lib";
+import { Assert } from "@vbyte/util";
 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";

package/dist/lib/tx/decode.js

@@ -1,13 +1,14 @@
 import { Stream } from "@vbyte/buff";
-import { Assert } from "@vbyte/micro-lib/assert";
+import { Assert } from "@vbyte/util";
 import { COINBASE, MAX_VARINT_SIZE } from "../../const.js";
+import { DecodingError } from "../../error.js";
 const MAX_TX_SIZE = 4_000_000;
 const MAX_TX_ELEMENTS = 100_000;
 export function decode_tx(txdata, use_segwit = true) {
-    Assert.is_bytes(txdata, "txdata must be hex or bytes");
+    Assert.ok(typeof txdata === "string" || txdata instanceof Uint8Array, "txdata must be hex or bytes");
     const txSize = typeof txdata === "string" ? txdata.length / 2 : txdata.length;
     if (txSize > MAX_TX_SIZE) {
-        throw new Error(`Transaction size ${txSize} exceeds maximum ${MAX_TX_SIZE} bytes`);
+        throw new DecodingError(`Transaction size ${txSize} exceeds maximum ${MAX_TX_SIZE} bytes`);
     }
     const stream = new Stream(txdata);
     const version = read_version(stream);
@@ -34,7 +35,7 @@ function check_witness_flag(stream) {
             return true;
         }
         else {
-            throw new Error(`Invalid witness flag: ${flag}`);
+            throw new DecodingError(`Invalid witness flag: ${flag}`, 1);
         }
     }
     return false;
@@ -43,7 +44,7 @@ function read_inputs(stream) {
     const inputs = [];
     const vinCount = stream.read_varint();
     if (vinCount > MAX_TX_ELEMENTS) {
-        throw new Error(`Input count ${vinCount} exceeds maximum ${MAX_TX_ELEMENTS}`);
+        throw new DecodingError(`Input count ${vinCount} exceeds maximum ${MAX_TX_ELEMENTS}`);
     }
     for (let i = 0; i < vinCount; i++) {
         const txinput = read_vin(stream);
@@ -84,14 +85,15 @@ function read_outputs(stream) {
     const outputs = [];
     const vcount = stream.read_varint();
     if (vcount > MAX_TX_ELEMENTS) {
-        throw new Error(`Output count ${vcount} exceeds maximum ${MAX_TX_ELEMENTS}`);
+        throw new DecodingError(`Output count ${vcount} exceeds maximum ${MAX_TX_ELEMENTS}`);
     }
     for (let i = 0; i < vcount; i++) {
         try {
             outputs.push(read_vout(stream));
         }
-        catch (_error) {
-            throw new Error(`failed to decode output at index ${i}`);
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new DecodingError(`Failed to decode output at index ${i}: ${message}`);
         }
     }
     return outputs;
@@ -106,12 +108,12 @@ function read_witness(stream) {
     const stack = [];
     const count = stream.read_varint();
     if (count > MAX_TX_ELEMENTS) {
-        throw new Error(`Witness element count ${count} exceeds maximum ${MAX_TX_ELEMENTS}`);
+        throw new DecodingError(`Witness element count ${count} exceeds maximum ${MAX_TX_ELEMENTS}`);
     }
     for (let i = 0; i < count; i++) {
         const element = read_payload(stream);
         if (element === null) {
-            throw new Error(`failed to decode witness element at index ${i}`);
+            throw new DecodingError(`Failed to decode witness element at index ${i}`);
         }
         stack.push(element);
     }
@@ -120,7 +122,7 @@ function read_witness(stream) {
 export function read_payload(stream) {
     const size = stream.read_varint("le");
     if (size > MAX_VARINT_SIZE) {
-        throw new Error(`Payload size ${size} exceeds maximum ${MAX_VARINT_SIZE}`);
+        throw new DecodingError(`Payload size ${size} exceeds maximum ${MAX_VARINT_SIZE}`);
     }
     return size > 0 ? stream.read(size).hex : null;
 }

package/dist/lib/tx/encode.js

@@ -1,5 +1,5 @@
 import { Buff } from "@vbyte/buff";
-import { Assert } from "@vbyte/micro-lib";
+import { Assert } from "@vbyte/util";
 import { COINBASE } from "../../const.js";
 import { assert_tx_data } from "./validate.js";
 export function encode_tx(txdata, use_segwit = true) {

package/dist/lib/tx/parse.js

@@ -1,4 +1,4 @@
-import { Assert } from "@vbyte/micro-lib/assert";
+import { Assert } from "@vbyte/util";
 import { create_tx, create_tx_output } from "./create.js";
 import { decode_tx } from "./decode.js";
 import { assert_tx_template } from "./validate.js";
@@ -31,14 +31,14 @@ export function serialize_tx(txdata) {
         if (e.prevout !== null) {
             vin.push({
                 script_pk: e.prevout.script_pk,
-                value: Number(e.prevout.value),
+                value: String(e.prevout.value),
             });
         }
     }
     for (const e of tx.vout) {
         vout.push({
             script_pk: e.script_pk,
-            value: Number(e.value),
+            value: String(e.value),
         });
     }
     return { version, locktime, vin, vout };

package/dist/lib/tx/size.js

@@ -4,16 +4,14 @@ import { parse_tx } from "./parse.js";
 const WIT_FLAG_BYTES = 2;
 export function get_vsize(bytes) {
     const weight = Buff.bytes(bytes).length;
-    const remain = weight % 4 > 0 ? 1 : 0;
-    return Math.ceil(weight / 4) + remain;
+    return Math.ceil(weight / 4);
 }
 export function get_txsize(txdata) {
     const json = parse_tx(txdata);
     const base = encode_tx(json, false).length;
     const total = encode_tx(json, true).length;
     const weight = base * 3 + total;
-    const remain = weight % 4 > 0 ? 1 : 0;
-    const vsize = Math.ceil(weight / 4) + remain;
+    const vsize = Math.ceil(weight / 4);
     return { base, total, vsize, weight };
 }
 export function get_vin_size(vin) {

package/dist/lib/tx/util.js

@@ -1,7 +1,6 @@
 import { Buff } from "@vbyte/buff";
-import { Test } from "@vbyte/micro-lib";
-import { Assert } from "@vbyte/micro-lib/assert";
-import { hash256 } from "@vbyte/micro-lib/hash";
+import { Assert, Test } from "@vbyte/util";
+import { hash256 } from "@vbyte/crypto/hash";
 import { DEFAULT } from "../../const.js";
 import { decode_tx } from "./decode.js";
 import { encode_tx } from "./encode.js";

package/dist/lib/tx/validate.js

@@ -1,28 +1,56 @@
 import * as Schema from "../../schema/index.js";
+import { ValidationError } from "../../error.js";
+function format_zod_error(error) {
+    const issues = error.issues.map((issue) => {
+        const path = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
+        return `${path}${issue.message}`;
+    });
+    return issues.join("; ");
+}
 export function assert_tx_template(txdata) {
-    Schema.tx.tx_template.parse(txdata);
+    const result = Schema.tx.tx_template.safeParse(txdata);
+    if (!result.success) {
+        throw new ValidationError(`invalid transaction template: ${format_zod_error(result.error)}`);
+    }
 }
 export function assert_has_prevouts(vin) {
-    if (vin.some((txin) => txin.prevout === null)) {
-        throw new Error("transaction missing prevouts");
+    const missingIdx = vin.findIndex((txin) => txin.prevout === null || txin.prevout === undefined);
+    if (missingIdx !== -1) {
+        throw new ValidationError(`transaction input at index ${missingIdx} is missing prevout data. ` +
+            `Prevout (previous output) is required for signing`);
     }
 }
 export function assert_tx_data(txdata) {
-    Schema.tx.tx_data.parse(txdata);
+    const result = Schema.tx.tx_data.safeParse(txdata);
+    if (!result.success) {
+        throw new ValidationError(`invalid transaction data: ${format_zod_error(result.error)}`);
+    }
 }
 export function assert_tx_spend_data(txdata) {
     assert_tx_data(txdata);
     assert_has_prevouts(txdata.vin);
 }
 export function assert_tx_input(tx_input) {
-    Schema.tx.tx_input.parse(tx_input);
+    const result = Schema.tx.tx_input.safeParse(tx_input);
+    if (!result.success) {
+        throw new ValidationError(`invalid transaction input: ${format_zod_error(result.error)}`);
+    }
 }
 export function assert_tx_output(tx_output) {
-    Schema.tx.tx_output.parse(tx_output);
+    const result = Schema.tx.tx_output.safeParse(tx_output);
+    if (!result.success) {
+        throw new ValidationError(`invalid transaction output: ${format_zod_error(result.error)}`);
+    }
 }
 export function assert_vin_template(vin) {
-    Schema.tx.vin_template.parse(vin);
+    const result = Schema.tx.vin_template.safeParse(vin);
+    if (!result.success) {
+        throw new ValidationError(`invalid input template: ${format_zod_error(result.error)}`);
+    }
 }
 export function assert_vout_template(vout) {
-    Schema.tx.vout_template.parse(vout);
+    const result = Schema.tx.vout_template.safeParse(vout);
+    if (!result.success) {
+        throw new ValidationError(`invalid output template: ${format_zod_error(result.error)}`);
+    }
 }

package/dist/lib/witness/util.js

@@ -1,5 +1,5 @@
 import { Buff } from "@vbyte/buff";
-import { Assert } from "@vbyte/micro-lib";
+import { Assert } from "@vbyte/util";
 const WIT_LENGTH_BYTE = 1;
 export function get_witness_size(witness) {
     const stack = witness.map((e) => Buff.bytes(e));