@vbyte/btc-dev 1.1.8 → 2.0.0

package/dist/lib/tx/decode.js

@@ -1,13 +1,18 @@
-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/micro-lib/assert";
+import { COINBASE, MAX_VARINT_SIZE } from "../../const.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.is_bytes(txdata, "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`);
+    }
     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) {
@@ -36,7 +41,10 @@ function check_witness_flag(stream) {
 }
 function read_inputs(stream) {
     const inputs = [];
-    const vinCount = stream.varint();
+    const vinCount = stream.read_varint();
+    if (vinCount > MAX_TX_ELEMENTS) {
+        throw new Error(`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 +58,40 @@ 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 Error(`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)}`);
+        catch (_error) {
+            throw new Error(`failed to decode output at index ${i}`);
         }
     }
     return outputs;
@@ -72,24 +99,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 Error(`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 Error(`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 Error(`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/micro-lib";
+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/micro-lib/assert";
+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: Number(e.prevout.value),
             });
         }
     }
     for (const e of tx.vout) {
         vout.push({
             script_pk: e.script_pk,
-            value: Number(e.value)
+            value: Number(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,10 +1,10 @@
-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;
+    const remain = weight % 4 > 0 ? 1 : 0;
     return Math.ceil(weight / 4) + remain;
 }
 export function get_txsize(txdata) {
@@ -12,7 +12,7 @@ export function get_txsize(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 remain = weight % 4 > 0 ? 1 : 0;
     const vsize = Math.ceil(weight / 4) + remain;
     return { base, total, vsize, weight };
 }
@@ -26,10 +26,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,12 @@
-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 { Test } from "@vbyte/micro-lib";
+import { Assert } from "@vbyte/micro-lib/assert";
+import { hash256 } from "@vbyte/micro-lib/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 +16,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 +41,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 +57,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),
+    };
 }

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,10 +1,10 @@
-import * as Schema from '../../schema/index.js';
+import * as Schema from "../../schema/index.js";
 export function assert_tx_template(txdata) {
     Schema.tx.tx_template.parse(txdata);
 }
 export function assert_has_prevouts(vin) {
-    if (vin.some(txin => txin.prevout === null)) {
-        throw new Error('transaction missing prevouts');
+    if (vin.some((txin) => txin.prevout === null)) {
+        throw new Error("transaction missing prevouts");
     }
 }
 export function assert_tx_data(txdata) {

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/micro-lib";
 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");
 }