@vbyte/btc-dev 1.0.0

package/dist/lib/tx/size.js

@@ -0,0 +1,48 @@
+import { Buff } from '@vbyte/buff';
+import { parse_tx_data } from './parse.js';
+import { encode_tx_data, encode_tx_inputs, encode_tx_outputs, encode_tx_vout, encode_vin, encode_vin_witness } from './encode.js';
+const WIT_FLAG_BYTES = 2;
+const WIT_LENGTH_BYTE = 1;
+export function get_vsize(bytes) {
+    const weight = Buff.bytes(bytes).length;
+    const remain = (weight % 4 > 0) ? 1 : 0;
+    return Math.floor(weight / 4) + remain;
+}
+export function get_txsize(txdata) {
+    const json = parse_tx_data(txdata);
+    const base = encode_tx_data(json, false).length;
+    const size = encode_tx_data(json, true).length;
+    const weight = base * 3 + size;
+    const remain = (weight % 4 > 0) ? 1 : 0;
+    const vsize = Math.floor(weight / 4) + remain;
+    return { base, real: size, vsize, weight };
+}
+export function get_vin_size(vin) {
+    const bytes = encode_tx_inputs(vin);
+    return bytes.length;
+}
+export function get_vout_size(vout) {
+    const bytes = encode_tx_outputs(vout);
+    return bytes.length;
+}
+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);
+}
+export function get_txin_size(txinput) {
+    const bytes = encode_vin(txinput);
+    return bytes.length;
+}
+export function get_txout_size(txoutput) {
+    const bytes = encode_tx_vout(txoutput);
+    return bytes.length;
+}
+export function get_witness_size(witness) {
+    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 { size, vsize };
+}

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

@@ -0,0 +1,7 @@
+import { SpendInput, TxData, TxInput, TxInputTemplate, TxOutput, 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 SpendInput[];
+export declare function assert_tx_data(txdata: unknown): asserts txdata is TxData;
+export declare function assert_tx_input(tx_input: unknown): asserts tx_input is TxInput;
+export declare function assert_tx_output(tx_output: unknown): asserts tx_output is TxOutput;
+export declare function assert_vin_template(vin_template: unknown): asserts vin_template is TxInputTemplate;

package/dist/lib/tx/validate.js

@@ -0,0 +1,21 @@
+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');
+    }
+}
+export function assert_tx_data(txdata) {
+    Schema.tx.tx_data.parse(txdata);
+}
+export function assert_tx_input(tx_input) {
+    Schema.tx.tx_input.parse(tx_input);
+}
+export function assert_tx_output(tx_output) {
+    Schema.tx.tx_output.parse(tx_output);
+}
+export function assert_vin_template(vin_template) {
+    Schema.tx.vin_template.parse(vin_template);
+}

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

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

package/dist/lib/tx/witness.js

@@ -0,0 +1,85 @@
+import { Buff } from '@vbyte/buff';
+import { is_valid_script } from '../../lib/script/decode.js';
+import { TAPLEAF_VERSIONS } from '../../const.js';
+export function parse_witness_data(witness) {
+    const elems = witness.map(e => Buff.bytes(e));
+    const annex = parse_annex_data(elems);
+    if (annex !== null)
+        elems.pop();
+    const cblock = parse_cblock_data(elems);
+    if (cblock !== null)
+        elems.pop();
+    const type = parse_witness_type(elems, cblock);
+    const version = parse_witness_version(type);
+    const script = parse_witness_script(elems, type);
+    if (script !== null)
+        elems.pop();
+    const params = elems.map(e => e.hex);
+    return { annex, cblock, params, script, type, version };
+}
+function parse_annex_data(data) {
+    let elem = data.at(-1);
+    if (data.length > 1 &&
+        elem instanceof Uint8Array &&
+        elem[0] === 0x50) {
+        return new Buff(elem).hex;
+    }
+    else {
+        return null;
+    }
+}
+function parse_cblock_data(data) {
+    let elem = data.at(-1);
+    if (data.length > 1 &&
+        elem instanceof Uint8Array &&
+        elem.length > 32 &&
+        TAPLEAF_VERSIONS.includes(elem[0] & 0xfe)) {
+        return new Buff(elem).hex;
+    }
+    else {
+        return null;
+    }
+}
+function parse_witness_script(elems, type) {
+    let script;
+    switch (type) {
+        case 'p2tr-ts':
+            script = elems.at(-1);
+        case 'p2w-sh':
+            script = elems.at(-1);
+    }
+    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);
+    if (cblock !== null && param_x !== undefined) {
+        return 'p2tr-ts';
+    }
+    else if (elems.length === 2 &&
+        param_0 !== undefined &&
+        param_1 !== undefined &&
+        param_0.length >= 64 &&
+        param_1.length === 33) {
+        return 'p2w-pkh';
+    }
+    else if (elems.length === 1 &&
+        param_0 !== undefined &&
+        param_0.length === 64) {
+        return 'p2tr-pk';
+    }
+    else if (elems.length > 1 &&
+        param_x !== undefined &&
+        is_valid_script(param_x)) {
+        return 'p2w-sh';
+    }
+    else {
+        return 'unknown';
+    }
+}
+function parse_witness_version(type) {
+    if (type.startsWith('p2tr'))
+        return 1;
+    if (type.startsWith('p2w'))
+        return 0;
+    return null;
+}