@vbyte/btc-dev 1.1.8 → 2.1.0

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

@@ -1,4 +1,4 @@
-import { TxSpendInput, TxData, TxInput, TxInputTemplate, TxOutput, TxTemplate, TxOutputTemplate, TxSpendData } from '../../types/index.js';
+import type { TxData, TxInput, TxInputTemplate, TxOutput, TxOutputTemplate, TxSpendData, TxSpendInput, TxTemplate } from "../../types/index.js";
 export declare function assert_tx_template(txdata: unknown): asserts txdata is TxTemplate;
 export declare function assert_has_prevouts(vin: TxInput[]): asserts vin is TxSpendInput[];
 export declare function assert_tx_data(txdata: unknown): asserts txdata is TxData;

package/dist/lib/tx/validate.js

@@ -1,28 +1,56 @@
-import * as Schema from '../../schema/index.js';
+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/index.d.ts

@@ -1,2 +1,2 @@
-export * from './parse.js';
-export * from './util.js';
+export * from "./parse.js";
+export * from "./util.js";

package/dist/lib/witness/index.js

@@ -1,2 +1,2 @@
-export * from './parse.js';
-export * from './util.js';
+export * from "./parse.js";
+export * from "./util.js";

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

@@ -1,3 +1,3 @@
-import { Bytes } from '@vbyte/buff';
-import type { WitnessData } from '../../types/index.js';
+import { type Bytes } from "@vbyte/buff";
+import type { WitnessData } from "../../types/index.js";
 export declare function parse_witness(witness: Bytes[]): WitnessData;

package/dist/lib/witness/parse.js

@@ -1,9 +1,9 @@
-import { Buff } from '@vbyte/buff';
-import { is_valid_script } from '../../lib/script/decode.js';
-import { TAPLEAF_VERSIONS } from '../../const.js';
+import { Buff } from "@vbyte/buff";
+import { TAPLEAF_VERSIONS } from "../../const.js";
+import { is_valid_script } from "../../lib/script/decode.js";
 export function parse_witness(witness) {
-    const elems = witness.map(e => Buff.bytes(e));
-    const stack = witness.map(e => Buff.bytes(e).hex);
+    const elems = witness.map((e) => Buff.bytes(e));
+    const stack = witness.map((e) => Buff.bytes(e).hex);
     const annex = parse_annex_data(elems);
     if (annex !== null)
         elems.pop();
@@ -15,14 +15,12 @@ export function parse_witness(witness) {
     const script = parse_witness_script(elems, type);
     if (script !== null)
         elems.pop();
-    const params = elems.map(e => e.hex);
+    const params = elems.map((e) => e.hex);
     return { annex, cblock, params, script, stack, type, version };
 }
 function parse_annex_data(data) {
-    let elem = data.at(-1);
-    if (data.length > 1 &&
-        elem instanceof Uint8Array &&
-        elem[0] === 0x50) {
+    const elem = data.at(-1);
+    if (data.length > 1 && elem instanceof Uint8Array && elem[0] === 0x50) {
         return new Buff(elem).hex;
     }
     else {
@@ -30,7 +28,7 @@ function parse_annex_data(data) {
     }
 }
 function parse_cblock_data(data) {
-    let elem = data.at(-1);
+    const elem = data.at(-1);
     if (data.length > 1 &&
         elem instanceof Uint8Array &&
         elem.length > 32 &&
@@ -44,34 +42,37 @@ function parse_cblock_data(data) {
 function parse_witness_script(elems, type) {
     let script;
     switch (type) {
-        case 'p2ts':
+        case "p2ts":
             script = elems.at(-1);
-        case 'p2wsh':
+            break;
+        case "p2wsh":
             script = elems.at(-1);
+            break;
     }
-    return (script !== undefined) ? new Buff(script).hex : null;
+    return script !== undefined ? new Buff(script).hex : null;
 }
 function parse_witness_type(elems, cblock) {
-    let param_0 = elems.at(0), param_1 = elems.at(1), param_x = elems.at(-1);
+    const param_0 = elems.at(0), param_1 = elems.at(1), param_x = elems.at(-1);
     if (cblock !== null && param_x !== undefined) {
-        return 'p2ts';
+        return "p2ts";
     }
     else if (elems.length === 2 &&
         param_0 !== undefined &&
         param_1 !== undefined &&
-        param_0.length >= 64 &&
+        param_0.length >= 71 &&
+        param_0.length <= 73 &&
         param_1.length === 33) {
-        return 'p2wpkh';
+        return "p2wpkh";
     }
     else if (elems.length === 1 &&
         param_0 !== undefined &&
-        param_0.length === 64) {
-        return 'p2tr';
+        (param_0.length === 64 || param_0.length === 65)) {
+        return "p2tr";
     }
     else if (elems.length > 1 &&
         param_x !== undefined &&
         is_valid_script(param_x)) {
-        return 'p2wsh';
+        return "p2wsh";
     }
     else {
         return null;
@@ -80,9 +81,9 @@ function parse_witness_type(elems, cblock) {
 function parse_witness_version(type) {
     if (type === null)
         return null;
-    if (type.startsWith('p2w'))
+    if (type.startsWith("p2w"))
         return 0;
-    if (type.startsWith('p2t'))
+    if (type.startsWith("p2t"))
         return 1;
     return null;
 }

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

@@ -1,4 +1,4 @@
-import { Bytes } from '@vbyte/buff';
-import type { WitnessSize } from '../../types/index.js';
+import { type Bytes } from "@vbyte/buff";
+import type { WitnessSize } from "../../types/index.js";
 export declare function get_witness_size(witness: Bytes[]): WitnessSize;
 export declare function assert_witness(witness: unknown): asserts witness is Bytes[];

package/dist/lib/witness/util.js

@@ -1,13 +1,13 @@
-import { Buff } from '@vbyte/buff';
-import { Assert } from '@vbyte/micro-lib';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/util";
 const WIT_LENGTH_BYTE = 1;
 export function get_witness_size(witness) {
-    const stack = witness.map(e => Buff.bytes(e));
+    const stack = witness.map((e) => Buff.bytes(e));
     const size = stack.reduce((prev, next) => prev + next.length, 0);
     const vsize = Math.ceil(WIT_LENGTH_BYTE + size / 4);
     return { total: size, vsize };
 }
 export function assert_witness(witness) {
-    Assert.ok(Array.isArray(witness), 'witness must be an array');
-    Assert.ok(witness.every(e => Buff.is_bytes(e)), 'witness must be an array of strings or bytes');
+    Assert.ok(Array.isArray(witness), "witness must be an array");
+    Assert.ok(witness.every((e) => Buff.is_bytes(e)), "witness must be an array of strings or bytes");
 }