@vbyte/btc-dev 1.1.8 → 2.1.0

package/dist/lib/taproot/parse.js

@@ -1,11 +1,13 @@
-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 } 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) {
     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,9 +15,9 @@ 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);
-    return { cblock: cblk, params, script, tapkey: tapkey.hex, tweak: tweak.hex };
+    const tapkey = ECC.tweak_pubkey(cblk.int_key, tweak, "bip340");
+    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,21 +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.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,23 @@
-import { Buff } from '@vbyte/buff';
-import { encode_tapbranch } from './encode.js';
+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) {
     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 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];
         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 +39,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 +50,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/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";
 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;

package/dist/lib/tx/decode.js

@@ -1,13 +1,19 @@
-import { Stream } from '@vbyte/buff';
-import { Assert } from '@vbyte/micro-lib/assert';
-import { parse_error } from '@vbyte/micro-lib/util';
-import { COINBASE } from '../../const.js';
+import { Stream } from "@vbyte/buff";
+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 DecodingError(`Transaction size ${txSize} exceeds maximum ${MAX_TX_SIZE} bytes`);
+    }
     const stream = new Stream(txdata);
     const version = read_version(stream);
     let has_witness = check_witness_flag(stream);
-    has_witness = (use_segwit) ? has_witness : false;
+    has_witness = use_segwit ? has_witness : false;
     const vin = read_inputs(stream);
     const vout = read_outputs(stream);
     if (has_witness) {
@@ -29,14 +35,17 @@ 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;
 }
 function read_inputs(stream) {
     const inputs = [];
-    const vinCount = stream.varint();
+    const vinCount = stream.read_varint();
+    if (vinCount > 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);
         inputs.push(txinput);
@@ -50,21 +59,41 @@ function read_vin(stream) {
     const sequence = stream.read(4).reverse().num;
     const witness = [];
     if (txid === COINBASE.TXID && vout === COINBASE.VOUT) {
-        return { coinbase: script_sig, prevout: null, script_sig: null, sequence, txid, vout, witness };
+        return {
+            coinbase: script_sig,
+            prevout: null,
+            script_sig: null,
+            sequence,
+            txid,
+            vout,
+            witness,
+        };
     }
     else {
-        return { coinbase: null, prevout: null, script_sig, sequence, txid, vout, witness };
+        return {
+            coinbase: null,
+            prevout: null,
+            script_sig,
+            sequence,
+            txid,
+            vout,
+            witness,
+        };
     }
 }
 function read_outputs(stream) {
     const outputs = [];
-    const vcount = stream.varint();
+    const vcount = stream.read_varint();
+    if (vcount > 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: ${i}: ${parse_error(error)}`);
+            const message = error instanceof Error ? error.message : String(error);
+            throw new DecodingError(`Failed to decode output at index ${i}: ${message}`);
         }
     }
     return outputs;
@@ -72,24 +101,30 @@ function read_outputs(stream) {
 function read_vout(stream) {
     const value = stream.read(8).reverse().big;
     const script_pk = read_payload(stream);
-    Assert.exists(script_pk, 'failed to decode script_pk');
+    Assert.exists(script_pk, "failed to decode script_pk");
     return { value, script_pk };
 }
 function read_witness(stream) {
     const stack = [];
-    const count = stream.varint();
+    const count = stream.read_varint();
+    if (count > 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: ' + i);
+            throw new DecodingError(`Failed to decode witness element at index ${i}`);
         }
         stack.push(element);
     }
     return stack;
 }
 export function read_payload(stream) {
-    const size = stream.varint('le');
-    return (size > 0) ? stream.read(size).hex : null;
+    const size = stream.read_varint("le");
+    if (size > MAX_VARINT_SIZE) {
+        throw new DecodingError(`Payload size ${size} exceeds maximum ${MAX_VARINT_SIZE}`);
+    }
+    return size > 0 ? stream.read(size).hex : null;
 }
 function read_locktime(stream) {
     return stream.read(4).reverse().to_num();

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

@@ -1,5 +1,5 @@
-import { Buff } from '@vbyte/buff';
-import { TxInput, TxOutput, TxData } from '../../types/index.js';
+import { Buff } from "@vbyte/buff";
+import type { TxData, TxInput, TxOutput } from "../../types/index.js";
 export declare function encode_tx(txdata: TxData, use_segwit?: boolean): Buff;
 export declare function encode_tx_version(num: number): Buff;
 export declare function encode_txin_txid(txid: string): Buff;

package/dist/lib/tx/encode.js

@@ -1,13 +1,13 @@
-import { Buff } from '@vbyte/buff';
-import { Assert } from '@vbyte/micro-lib';
-import { assert_tx_data } from './validate.js';
-import { COINBASE } from '../../const.js';
+import { Buff } from "@vbyte/buff";
+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) {
     assert_tx_data(txdata);
     const { version, vin, vout, locktime } = txdata;
     const buffer = [encode_tx_version(version)];
     if (use_segwit) {
-        buffer.push(Buff.hex('0001'));
+        buffer.push(Buff.hex("0001"));
     }
     buffer.push(encode_tx_inputs(vin));
     buffer.push(encode_tx_outputs(vout));
@@ -32,7 +32,7 @@ export function encode_txin_sequence(sequence) {
     return Buff.num(sequence, 4).reverse();
 }
 export function encode_tx_inputs(vin) {
-    const raw = [Buff.varint(vin.length, 'le')];
+    const raw = [Buff.create_varint(vin.length, "le")];
     for (const input of vin) {
         raw.push(encode_vin(input));
     }
@@ -44,7 +44,7 @@ export function encode_vin(txin) {
             encode_txin_txid(COINBASE.TXID),
             encode_txin_vout(COINBASE.VOUT),
             encode_script_data(txin.coinbase),
-            encode_txin_sequence(txin.sequence)
+            encode_txin_sequence(txin.sequence),
         ]);
     }
     else {
@@ -52,7 +52,7 @@ export function encode_vin(txin) {
             encode_txin_txid(txin.txid),
             encode_txin_vout(txin.vout),
             encode_script_data(txin.script_sig),
-            encode_txin_sequence(txin.sequence)
+            encode_txin_sequence(txin.sequence),
         ]);
     }
 }
@@ -60,7 +60,7 @@ export function encode_vout_value(value) {
     return Buff.big(value, 8).reverse();
 }
 export function encode_tx_outputs(vout) {
-    const buffer = [Buff.varint(vout.length, 'le')];
+    const buffer = [Buff.create_varint(vout.length, "le")];
     for (const output of vout) {
         buffer.push(encode_tx_vout(output));
     }
@@ -68,13 +68,10 @@ export function encode_tx_outputs(vout) {
 }
 export function encode_tx_vout(txout) {
     const { value, script_pk } = txout;
-    return Buff.join([
-        encode_vout_value(value),
-        encode_script_data(script_pk)
-    ]);
+    return Buff.join([encode_vout_value(value), encode_script_data(script_pk)]);
 }
 export function encode_vin_witness(data) {
-    const buffer = [Buff.varint(data.length)];
+    const buffer = [Buff.create_varint(data.length)];
     for (const param of data) {
         buffer.push(encode_script_data(param));
     }
@@ -86,9 +83,9 @@ export function encode_tx_locktime(locktime) {
 export function encode_script_data(script) {
     if (script !== null) {
         Assert.is_hex(script);
-        return Buff.hex(script).prefix_varint('le');
+        return Buff.hex(script).prefix_varint("le");
     }
     else {
-        return Buff.hex('00');
+        return Buff.hex("00");
     }
 }

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

@@ -1,7 +1,7 @@
-export * from './create.js';
-export * from './decode.js';
-export * from './encode.js';
-export * from './util.js';
-export * from './parse.js';
-export * from './size.js';
-export * from './validate.js';
+export * from "./create.js";
+export * from "./decode.js";
+export * from "./encode.js";
+export * from "./parse.js";
+export * from "./size.js";
+export * from "./util.js";
+export * from "./validate.js";

package/dist/lib/tx/index.js

@@ -1,7 +1,7 @@
-export * from './create.js';
-export * from './decode.js';
-export * from './encode.js';
-export * from './util.js';
-export * from './parse.js';
-export * from './size.js';
-export * from './validate.js';
+export * from "./create.js";
+export * from "./decode.js";
+export * from "./encode.js";
+export * from "./parse.js";
+export * from "./size.js";
+export * from "./util.js";
+export * from "./validate.js";

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

@@ -1,3 +1,3 @@
-import type { TxData, TxOutputTemplate } from '../../types/index.js';
+import type { TxData, TxOutputTemplate } from "../../types/index.js";
 export declare function parse_tx(txdata: unknown, prevouts?: TxOutputTemplate[]): TxData;
 export declare function serialize_tx(txdata: unknown): Record<string, unknown>;

package/dist/lib/tx/parse.js

@@ -1,10 +1,10 @@
-import { Assert } from '@vbyte/micro-lib/assert';
-import { decode_tx } from './decode.js';
-import { assert_tx_template } from './validate.js';
-import { create_tx, create_tx_output } from './create.js';
+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";
 export function parse_tx(txdata, prevouts) {
     let tx;
-    if (typeof txdata === 'string' || txdata instanceof Uint8Array) {
+    if (typeof txdata === "string" || txdata instanceof Uint8Array) {
         tx = decode_tx(txdata);
     }
     else {
@@ -12,10 +12,10 @@ export function parse_tx(txdata, prevouts) {
         tx = create_tx(txdata);
     }
     if (prevouts) {
-        Assert.has_items(prevouts, 'prevouts must be a non-empty array');
+        Assert.has_items(prevouts, "prevouts must be a non-empty array");
         for (const [idx, vin] of tx.vin.entries()) {
             const prevout = prevouts.at(idx);
-            Assert.exists(prevout, 'prevout not found for input index: ' + idx);
+            Assert.exists(prevout, `prevout not found for input index: ${idx}`);
             vin.prevout = create_tx_output(prevout);
         }
     }
@@ -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.d.ts

@@ -1,5 +1,5 @@
-import { Bytes } from '@vbyte/buff';
-import type { TxData, TxInput, TxOutput, TxSize } from '../../types/index.js';
+import { type Bytes } from "@vbyte/buff";
+import type { TxData, TxInput, TxOutput, TxSize } from "../../types/index.js";
 export declare function get_vsize(bytes: Bytes): number;
 export declare function get_txsize(txdata: string | TxData): TxSize;
 export declare function get_vin_size(vin: TxInput[]): number;

package/dist/lib/tx/size.js

@@ -1,19 +1,17 @@
-import { Buff } from '@vbyte/buff';
-import { parse_tx } from './parse.js';
-import { encode_tx, encode_tx_inputs, encode_tx_outputs, encode_tx_vout, encode_vin, encode_vin_witness } from './encode.js';
+import { Buff } from "@vbyte/buff";
+import { encode_tx, encode_tx_inputs, encode_tx_outputs, encode_tx_vout, encode_vin, encode_vin_witness, } from "./encode.js";
+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) {
@@ -26,10 +24,10 @@ export function get_vout_size(vout) {
 }
 export function get_segwit_size(txinputs) {
     const segwit_data = txinputs
-        .filter(e => e.witness.length > 0)
-        .map(e => e.witness);
-    return WIT_FLAG_BYTES + segwit_data
-        .reduce((acc, e) => acc + encode_vin_witness(e).length, 0);
+        .filter((e) => e.witness.length > 0)
+        .map((e) => e.witness);
+    return (WIT_FLAG_BYTES +
+        segwit_data.reduce((acc, e) => acc + encode_vin_witness(e).length, 0));
 }
 export function get_txin_size(txinput) {
     const bytes = encode_vin(txinput);

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

@@ -1,5 +1,5 @@
-import { Buff } from '@vbyte/buff';
-import type { TxData, TxOutput, TxOutputTemplate, TxValue } from '../../types/index.js';
+import { Buff } from "@vbyte/buff";
+import type { TxData, TxOutput, TxOutputTemplate, TxValue } from "../../types/index.js";
 export declare function transcode_tx(txdata: string | Uint8Array, use_segwit?: boolean): Buff;
 export declare function get_txid(txdata: string | Uint8Array | TxData): string;
 export declare function get_txhash(txdata: string | Uint8Array | TxData): string;

package/dist/lib/tx/util.js

@@ -1,12 +1,11 @@
-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 { decode_tx } from './decode.js';
-import { encode_tx } from './encode.js';
-import { parse_tx } from './parse.js';
-import { assert_tx_template } from './validate.js';
-import { DEFAULT } from '../../const.js';
+import { Buff } from "@vbyte/buff";
+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";
+import { parse_tx } from "./parse.js";
+import { assert_tx_template } from "./validate.js";
 export function transcode_tx(txdata, use_segwit = true) {
     const decoded = decode_tx(txdata);
     return encode_tx(decoded, use_segwit);
@@ -16,21 +15,21 @@ export function get_txid(txdata) {
     if (txdata instanceof Uint8Array) {
         buffer = transcode_tx(txdata, false);
     }
-    else if (typeof txdata === 'object') {
+    else if (typeof txdata === "object") {
         assert_tx_template(txdata);
         buffer = encode_tx(txdata, false);
     }
-    else if (typeof txdata === 'string') {
+    else if (typeof txdata === "string") {
         Assert.is_hex(txdata);
         buffer = transcode_tx(txdata, false);
     }
     else {
-        throw new TypeError('invalid txdata type: ' + typeof txdata);
+        throw new TypeError(`invalid txdata type: ${typeof txdata}`);
     }
     return hash256(buffer).reverse().hex;
 }
 export function get_txhash(txdata) {
-    if (typeof txdata === 'object') {
+    if (typeof txdata === "object") {
         assert_tx_template(txdata);
         txdata = encode_tx(txdata, true);
     }
@@ -41,13 +40,13 @@ export function get_tx_value(txdata) {
     assert_tx_template(tx);
     const vin = tx.vin.reduce((acc, txin) => acc + (txin.prevout?.value ?? 0n), 0n);
     const vout = tx.vout.reduce((acc, txout) => acc + txout.value, 0n);
-    const fees = (vin > vout) ? (vin - vout) : 0n;
+    const fees = vin > vout ? vin - vout : 0n;
     return { fees, vin, vout };
 }
 export function get_prevouts(txdata) {
     assert_tx_template(txdata);
-    const prevouts = txdata.vin.map(e => e.prevout);
-    Assert.ok(prevouts.every(e => e !== null), 'prevouts missing from tx');
+    const prevouts = txdata.vin.map((e) => e.prevout);
+    Assert.ok(prevouts.every((e) => e !== null), "prevouts missing from tx");
     return prevouts;
 }
 export function normalize_sequence(sequence) {
@@ -57,15 +56,18 @@ export function normalize_sequence(sequence) {
         return Buff.hex(sequence, 4).reverse().num;
     if (Test.is_uint(sequence))
         return sequence;
-    throw new Error('invalid sequence value: ' + String(sequence));
+    throw new Error(`invalid sequence value: ${String(sequence)}`);
 }
 export function normalize_value(value) {
     if (Test.is_uint(value))
         return BigInt(value);
-    if (typeof value === 'bigint')
+    if (typeof value === "bigint")
         return value;
-    throw new TypeError('invalid output value: ' + String(value));
+    throw new TypeError(`invalid output value: ${String(value)}`);
 }
 export function normalize_prevout(prevout) {
-    return { script_pk: prevout.script_pk, value: normalize_value(prevout.value) };
+    return {
+        script_pk: prevout.script_pk,
+        value: normalize_value(prevout.value),
+    };
 }