@vbyte/btc-dev 1.0.0

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

@@ -0,0 +1,11 @@
+import type { ControlBlock } from '../../types/index.js';
+export declare function parse_taproot_witness(witness: string[]): {
+    cblock: ControlBlock;
+    params: string[];
+    script: string;
+    tapkey: string;
+    tweak: string;
+};
+export declare function parse_cblock(cblock: string | Uint8Array): ControlBlock;
+export declare function parse_cblock_parity(cbits: number): number[];
+export declare function parse_pubkey_parity(pubkey: string | Uint8Array): number;

package/dist/lib/taproot/parse.js

@@ -0,0 +1,47 @@
+import { Buff, Stream } from '@vbyte/buff';
+import { Assert, ECC } from '@vbyte/micro-lib';
+import { parse_witness_data } from '../../lib/tx/witness.js';
+import { encode_tapbranch, encode_tapscript, encode_taptweak, } from './encode.js';
+export function parse_taproot_witness(witness) {
+    const { cblock, params, script } = parse_witness_data(witness);
+    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;
+    for (const leaf of cblk.path) {
+        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 };
+}
+export function parse_cblock(cblock) {
+    const buffer = new Stream(cblock);
+    const cbyte = buffer.read(1).num;
+    const int_key = buffer.read(32).hex;
+    const [version, parity] = parse_cblock_parity(cbyte);
+    const path = [];
+    while (buffer.size >= 32) {
+        path.push(buffer.read(32).hex);
+    }
+    if (buffer.size !== 0) {
+        throw new Error('Non-empty buffer on control block: ' + String(buffer));
+    }
+    return { int_key, path, parity, version };
+}
+export function parse_cblock_parity(cbits) {
+    return (cbits % 2 === 0)
+        ? [cbits - 0, 0x02]
+        : [cbits - 1, 0x03];
+}
+export function parse_pubkey_parity(pubkey) {
+    Assert.size(pubkey, 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));
+}

package/dist/lib/taproot/tree.d.ts

@@ -0,0 +1,3 @@
+import type { TapTree, MerkleProof } from '../../types/index.js';
+export declare function get_merkle_root(leaves: TapTree): string;
+export declare function merkleize(taptree: TapTree, target?: string, path?: string[]): MerkleProof;

package/dist/lib/taproot/tree.js

@@ -0,0 +1,49 @@
+import { Buff } from '@vbyte/buff';
+import { encode_tapbranch } from './encode.js';
+export function get_merkle_root(leaves) {
+    return merkleize(leaves)[0];
+}
+export function merkleize(taptree, target, path = []) {
+    const leaves = [];
+    const tree = [];
+    if (taptree.length < 1) {
+        throw new Error('Tree is empty!');
+    }
+    for (let i = 0; i < taptree.length; i++) {
+        const bytes = taptree[i];
+        if (Array.isArray(bytes)) {
+            let [tapleaf, new_target, branches] = merkleize(bytes, target);
+            target = new_target;
+            leaves.push(tapleaf);
+            for (const branch of branches) {
+                path.push(branch);
+            }
+        }
+        else {
+            const leaf = Buff.bytes(bytes).hex;
+            leaves.push(leaf);
+        }
+    }
+    if (leaves.length === 1) {
+        return [leaves[0], target, path];
+    }
+    leaves.sort();
+    if (leaves.length % 2 !== 0) {
+        leaves.push(leaves[leaves.length - 1]);
+    }
+    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 (target === leaves[i]) {
+                path.push(leaves[i + 1]);
+                target = branch;
+            }
+            else if (target === leaves[i + 1]) {
+                path.push(leaves[i]);
+                target = branch;
+            }
+        }
+    }
+    return merkleize(tree, target, path);
+}

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

@@ -0,0 +1,6 @@
+import type { TxData, TxInputTemplate, TxInput, TxOutput, TxTemplate, SpendInput, CoinbaseInput } from '../../types/index.js';
+export declare function create_coinbase_input(config: TxInputTemplate | TxInput): CoinbaseInput;
+export declare function create_spend_input(config: TxInputTemplate | TxInput): SpendInput;
+export declare function create_tx_input(config: TxInputTemplate | TxInput): TxInput;
+export declare function create_tx_output(config: TxOutput): TxOutput;
+export declare function create_tx_data(config: TxTemplate | TxData): TxData;

package/dist/lib/tx/create.js

@@ -0,0 +1,54 @@
+import { Assert } from '@vbyte/micro-lib';
+import { COINBASE, DEFAULT } from '../../const.js';
+import { assert_tx_output, assert_tx_template, assert_vin_template } from './validate.js';
+export function create_coinbase_input(config) {
+    assert_vin_template(config);
+    Assert.exists(config.coinbase, 'coinbase is required');
+    const coinbase = config.coinbase;
+    const prevout = null;
+    const script_sig = null;
+    const sequence = config.sequence ?? DEFAULT.SEQUENCE;
+    const txid = COINBASE.TXID;
+    const vout = COINBASE.VOUT;
+    const witness = config.witness ?? [];
+    return { coinbase, prevout, script_sig, sequence, witness, txid, vout };
+}
+export function create_spend_input(config) {
+    assert_vin_template(config);
+    Assert.exists(config.prevout, 'prevout is required');
+    const prevout = config.prevout;
+    const coinbase = null;
+    const script_sig = config.script_sig ?? null;
+    const sequence = config.sequence ?? DEFAULT.SEQUENCE;
+    const witness = config.witness ?? [];
+    return { ...config, coinbase, prevout, script_sig, sequence, witness };
+}
+export function create_tx_input(config) {
+    assert_vin_template(config);
+    Assert.exists(config.txid, 'txid is required');
+    Assert.exists(config.vout, 'vout is required');
+    const coinbase = config.coinbase ?? null;
+    const prevout = config.prevout ?? null;
+    const script_sig = config.script_sig ?? null;
+    const sequence = config.sequence ?? DEFAULT.SEQUENCE;
+    const witness = config.witness ?? [];
+    if (coinbase !== null)
+        return create_coinbase_input(config);
+    if (prevout !== null)
+        return create_spend_input(config);
+    return { ...config, coinbase, prevout, script_sig, sequence, witness };
+}
+export function create_tx_output(config) {
+    assert_tx_output(config);
+    const { script_pk, value } = config;
+    return { script_pk, value: BigInt(value) };
+}
+export function create_tx_data(config) {
+    assert_tx_template(config);
+    const { vin = [], vout = [] } = config;
+    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));
+    return { locktime, vin: inputs, vout: outputs, version };
+}

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

@@ -0,0 +1,9 @@
+import { Bytes, Stream } from '@vbyte/buff';
+import { TxData, TxOutput } from '../../types/index.js';
+interface TxEncoderConfig {
+    prevouts: TxOutput[];
+    segwit: boolean;
+}
+export declare function decode_tx_data(txbytes: Bytes, options?: Partial<TxEncoderConfig>): TxData;
+export declare function read_script(stream: Stream, varint?: boolean): string | null;
+export {};

package/dist/lib/tx/decode.js

@@ -0,0 +1,109 @@
+import { Stream } from '@vbyte/buff';
+import { Assert } from '@vbyte/micro-lib';
+import { parse_error } from '@vbyte/micro-lib/util';
+import { COINBASE } from '../../const.js';
+const DEFAULT_CONFIG = {
+    prevouts: [],
+    segwit: true
+};
+export function decode_tx_data(txbytes, options = {}) {
+    const config = { ...DEFAULT_CONFIG, ...options };
+    Assert.is_bytes(txbytes, 'txbytes must be hex or a unit array');
+    const stream = new Stream(txbytes);
+    const version = read_version(stream);
+    const has_witness = (config.segwit)
+        ? check_witness_flag(stream)
+        : false;
+    const vin = read_inputs(stream, config.prevouts);
+    const vout = read_outputs(stream);
+    if (has_witness) {
+        for (const txin of vin) {
+            txin.witness = read_witness(stream);
+        }
+    }
+    const locktime = read_locktime(stream);
+    return { version, vin, vout, locktime };
+}
+function read_version(stream) {
+    return stream.read(4).reverse().to_num();
+}
+function check_witness_flag(stream) {
+    const [marker, flag] = [...stream.peek(2)];
+    if (marker === 0) {
+        stream.read(2);
+        if (flag === 1) {
+            return true;
+        }
+        else {
+            throw new Error(`Invalid witness flag: ${flag}`);
+        }
+    }
+    return false;
+}
+function read_inputs(stream, prevouts) {
+    const inputs = [];
+    const vinCount = stream.varint();
+    for (let i = 0; i < vinCount; i++) {
+        const txinput = read_vin(stream, prevouts.at(i));
+        inputs.push(txinput);
+    }
+    return inputs;
+}
+function read_vin(stream, prevout = null) {
+    const txid = stream.read(32).reverse().hex;
+    const vout = stream.read(4).reverse().num;
+    const script_sig = read_script(stream, true);
+    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 };
+    }
+    else if (prevout !== null) {
+        return { coinbase: null, prevout, script_sig, sequence, txid, vout, witness };
+    }
+    else {
+        return { coinbase: null, prevout, script_sig, sequence, txid, vout, witness };
+    }
+}
+function read_outputs(stream) {
+    const outputs = [];
+    const vcount = stream.varint();
+    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)}`);
+        }
+    }
+    return outputs;
+}
+function read_vout(stream) {
+    const value = stream.read(8).reverse().big;
+    const script_pk = read_script(stream, true);
+    Assert.exists(script_pk, 'failed to decode script_pk');
+    return { value, script_pk };
+}
+function read_witness(stream) {
+    const stack = [];
+    const count = stream.varint();
+    for (let i = 0; i < count; i++) {
+        const element = read_script(stream, true);
+        if (element === null) {
+            throw new Error('failed to decode witness element: ' + i);
+        }
+        stack.push(element);
+    }
+    return stack;
+}
+export function read_script(stream, varint) {
+    const size = (varint === true)
+        ? stream.varint('le')
+        : stream.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

@@ -0,0 +1,15 @@
+import { Buff } from '@vbyte/buff';
+import { TxInput, TxOutput, TxData } from '../../types/index.js';
+export declare function encode_tx_data(txdata: TxData, segwit?: boolean): Buff;
+export declare function encode_tx_version(num: number): Buff;
+export declare function encode_txin_txid(txid: string): Buff;
+export declare function encode_txin_vout(vout: number): Buff;
+export declare function encode_txin_sequence(sequence: number): Buff;
+export declare function encode_tx_inputs(vin: TxInput[]): Buff;
+export declare function encode_vin(txin: TxInput): Buff;
+export declare function encode_vout_value(value: bigint): Buff;
+export declare function encode_tx_outputs(vout: TxOutput[]): Buff;
+export declare function encode_tx_vout(txout: TxOutput): Buff;
+export declare function encode_vin_witness(data: string[]): Buff;
+export declare function encode_tx_locktime(locktime: number): Buff;
+export declare function encode_script_data(script: string | null): Buff;

package/dist/lib/tx/encode.js

@@ -0,0 +1,94 @@
+import { Buff } from '@vbyte/buff';
+import { Assert } from '@vbyte/micro-lib';
+import { parse_tx_data } from './parse.js';
+import { COINBASE } from '../../const.js';
+export function encode_tx_data(txdata, segwit = true) {
+    const tx = parse_tx_data(txdata);
+    const { version, vin, vout, locktime } = tx;
+    const buffer = [encode_tx_version(version)];
+    if (segwit) {
+        buffer.push(Buff.hex('0001'));
+    }
+    buffer.push(encode_tx_inputs(vin));
+    buffer.push(encode_tx_outputs(vout));
+    if (segwit) {
+        for (const input of vin) {
+            buffer.push(encode_vin_witness(input.witness));
+        }
+    }
+    buffer.push(encode_tx_locktime(locktime));
+    return Buff.join(buffer);
+}
+export function encode_tx_version(num) {
+    return Buff.num(num, 4).reverse();
+}
+export function encode_txin_txid(txid) {
+    return Buff.hex(txid, 32).reverse();
+}
+export function encode_txin_vout(vout) {
+    return Buff.num(vout, 4).reverse();
+}
+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')];
+    for (const input of vin) {
+        raw.push(encode_vin(input));
+    }
+    return Buff.join(raw);
+}
+export function encode_vin(txin) {
+    if (txin.coinbase !== null) {
+        return Buff.join([
+            encode_txin_txid(COINBASE.TXID),
+            encode_txin_vout(COINBASE.VOUT),
+            encode_script_data(txin.coinbase),
+            encode_txin_sequence(txin.sequence)
+        ]);
+    }
+    else {
+        return Buff.join([
+            encode_txin_txid(txin.txid),
+            encode_txin_vout(txin.vout),
+            encode_script_data(txin.script_sig),
+            encode_txin_sequence(txin.sequence)
+        ]);
+    }
+}
+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')];
+    for (const output of vout) {
+        buffer.push(encode_tx_vout(output));
+    }
+    return Buff.join(buffer);
+}
+export function encode_tx_vout(txout) {
+    const { value, script_pk } = txout;
+    return Buff.join([
+        encode_vout_value(value),
+        encode_script_data(script_pk)
+    ]);
+}
+export function encode_vin_witness(data) {
+    const buffer = [Buff.varint(data.length)];
+    for (const param of data) {
+        buffer.push(encode_script_data(param));
+    }
+    return Buff.join(buffer);
+}
+export function encode_tx_locktime(locktime) {
+    return Buff.num(locktime, 4).reverse();
+}
+export function encode_script_data(script) {
+    if (script !== null) {
+        Assert.is_hex(script);
+        return Buff.hex(script).prefix_varint('le');
+    }
+    else {
+        return Buff.hex('00');
+    }
+}

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

@@ -0,0 +1,10 @@
+export * from './create.js';
+export * from './decode.js';
+export * from './encode.js';
+export * from './locktime.js';
+export * from './meta.js';
+export * from './parse.js';
+export * from './sequence.js';
+export * from './size.js';
+export * from './validate.js';
+export * from './witness.js';

package/dist/lib/tx/index.js

@@ -0,0 +1,10 @@
+export * from './create.js';
+export * from './decode.js';
+export * from './encode.js';
+export * from './locktime.js';
+export * from './meta.js';
+export * from './parse.js';
+export * from './sequence.js';
+export * from './size.js';
+export * from './validate.js';
+export * from './witness.js';

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

@@ -0,0 +1,7 @@
+import type { LocktimeInfo } from '../../types/index.js';
+export declare namespace Locktime {
+    const encode: typeof encode_locktime;
+    const decode: typeof decode_locktime;
+}
+export declare function encode_locktime(locktime: LocktimeInfo): number;
+export declare function decode_locktime(locktime: number): LocktimeInfo | null;

package/dist/lib/tx/locktime.js

@@ -0,0 +1,37 @@
+import { Assert } from '@vbyte/micro-lib';
+const LOCKTIME_THRESHOLD = 500000000;
+export var Locktime;
+(function (Locktime) {
+    Locktime.encode = encode_locktime;
+    Locktime.decode = decode_locktime;
+})(Locktime || (Locktime = {}));
+export function encode_locktime(locktime) {
+    switch (locktime.type) {
+        case 'timelock':
+            Assert.ok(locktime.stamp >= LOCKTIME_THRESHOLD, 'Invalid timestamp');
+            return locktime.stamp;
+        case 'heightlock':
+            Assert.ok(locktime.height > 0, 'height must be greater than 0');
+            Assert.ok(locktime.height < LOCKTIME_THRESHOLD, 'invalid block height');
+            return locktime.height;
+        default:
+            throw new Error('Invalid locktime type');
+    }
+}
+export function decode_locktime(locktime) {
+    if (isNaN(locktime) || locktime <= 0) {
+        return null;
+    }
+    if (locktime < LOCKTIME_THRESHOLD) {
+        return {
+            type: 'heightlock',
+            height: locktime
+        };
+    }
+    else {
+        return {
+            type: 'timelock',
+            stamp: locktime
+        };
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { TxData, TxOutput, TxOutputInfo, TxOutputType, TxValue, WitnessVersion } from '../../types/index.js';
+export declare function is_return_script(script: string): boolean;
+export declare function get_vout_info(txout: TxOutput): TxOutputInfo;
+export declare function get_vout_type(script: string): TxOutputType;
+export declare function get_vout_version(script: string): WitnessVersion;
+export declare function get_txid(txdata: string | TxData): string;
+export declare function get_txhash(txdata: string | TxData): string;
+export declare function get_tx_value(txdata: string | TxData): TxValue;

package/dist/lib/tx/meta.js

@@ -0,0 +1,48 @@
+import { hash256 } from '@vbyte/micro-lib/hash';
+import { LOCK_SCRIPT_REGEX } from '../../const.js';
+import { encode_tx_data } from './encode.js';
+import { parse_tx_data } from './parse.js';
+export function is_return_script(script) {
+    return script.startsWith('6a');
+}
+export function get_vout_info(txout) {
+    return {
+        type: get_vout_type(txout.script_pk),
+        version: get_vout_version(txout.script_pk)
+    };
+}
+export function get_vout_type(script) {
+    for (const [type, regex] of Object.entries(LOCK_SCRIPT_REGEX)) {
+        if (regex.test(script))
+            return type;
+    }
+    return 'unknown';
+}
+export function get_vout_version(script) {
+    const wit_ver = script.slice(0, 4);
+    switch (wit_ver) {
+        case '0014':
+            return 0;
+        case '5120':
+            return 1;
+        default:
+            return null;
+    }
+}
+export function get_txid(txdata) {
+    const json = parse_tx_data(txdata);
+    const data = encode_tx_data(json, false);
+    return hash256(data).reverse().hex;
+}
+export function get_txhash(txdata) {
+    const json = parse_tx_data(txdata);
+    const data = encode_tx_data(json, true);
+    return hash256(data).reverse().hex;
+}
+export function get_tx_value(txdata) {
+    const tx = parse_tx_data(txdata);
+    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;
+    return { fees, vin, vout };
+}

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

@@ -0,0 +1,2 @@
+import type { TxData } from '../../types/index.js';
+export declare function parse_tx_data(txdata: unknown): TxData;

package/dist/lib/tx/parse.js

@@ -0,0 +1,12 @@
+import { decode_tx_data } from './decode.js';
+import { create_tx_data } from './create.js';
+import { assert_tx_template } from './validate.js';
+export function parse_tx_data(txdata) {
+    if (typeof txdata === 'string') {
+        return decode_tx_data(txdata);
+    }
+    else {
+        assert_tx_template(txdata);
+        return create_tx_data(txdata);
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { SequenceConfig, SequenceInfo } from '../../types/index.js';
+export declare namespace Sequence {
+    const encode: typeof encode_sequence;
+    const decode: typeof decode_sequence;
+}
+export declare function encode_sequence(data: SequenceConfig): number;
+export declare function decode_sequence(sequence: number | string): SequenceInfo | null;

package/dist/lib/tx/sequence.js

@@ -0,0 +1,65 @@
+const TIMELOCK_DISABLE = 0x80000000;
+const TIMELOCK_TYPE = 0x00400000;
+const TIMELOCK_VALUE_MASK = 0x0000FFFF;
+const TIMELOCK_VALUE_MAX = 0xFFFF;
+const TIMELOCK_GRANULARITY = 512;
+export var Sequence;
+(function (Sequence) {
+    Sequence.encode = encode_sequence;
+    Sequence.decode = decode_sequence;
+})(Sequence || (Sequence = {}));
+export function encode_sequence(data) {
+    if (data.mode === 'height') {
+        const height = parse_height(data.height);
+        return (height & TIMELOCK_VALUE_MASK) >>> 0;
+    }
+    if (data.mode === 'stamp') {
+        const stamp = parse_stamp(data.stamp);
+        return (TIMELOCK_TYPE | (stamp & TIMELOCK_VALUE_MASK)) >>> 0;
+    }
+    throw new Error('invalid timelock mode: ' + data.mode);
+}
+export function decode_sequence(sequence) {
+    const seq = parse_sequence(sequence);
+    if (seq & TIMELOCK_DISABLE)
+        return null;
+    const value = seq & TIMELOCK_VALUE_MASK;
+    if (seq & TIMELOCK_TYPE) {
+        const stamp = value * TIMELOCK_GRANULARITY;
+        if (stamp > 0xFFFFFFFF) {
+            throw new Error('Decoded timestamp exceeds 32-bit limit');
+        }
+        return { mode: 'stamp', stamp };
+    }
+    else {
+        if (value > TIMELOCK_VALUE_MAX) {
+            throw new Error('Decoded height exceeds maximum');
+        }
+        return { mode: 'height', height: value };
+    }
+}
+function parse_sequence(sequence) {
+    const seq = (typeof sequence === 'string')
+        ? parseInt(sequence, 16)
+        : sequence;
+    if (!Number.isInteger(seq) || seq < 0 || seq > 0xFFFFFFFF) {
+        throw new Error(`invalid sequence value: ${seq}`);
+    }
+    return seq;
+}
+function parse_stamp(stamp) {
+    if (stamp === undefined || !Number.isInteger(stamp)) {
+        throw new Error(`timestamp must be a number`);
+    }
+    const ts = Math.floor(stamp / TIMELOCK_GRANULARITY);
+    if (!Number.isInteger(ts) || ts < 0 || ts > TIMELOCK_VALUE_MAX) {
+        throw new Error(`timelock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX} (in 512-second increments)`);
+    }
+    return ts;
+}
+function parse_height(height) {
+    if (height === undefined || !Number.isInteger(height) || height < 0 || height > TIMELOCK_VALUE_MAX) {
+        throw new Error(`Heightlock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX}`);
+    }
+    return height;
+}

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

@@ -0,0 +1,10 @@
+import { Bytes } from '@vbyte/buff';
+import type { TxData, TxInput, TxOutput, TxSize, WitnessSize } 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;
+export declare function get_vout_size(vout: TxOutput[]): number;
+export declare function get_segwit_size(txinputs: TxInput[]): number;
+export declare function get_txin_size(txinput: TxInput): number;
+export declare function get_txout_size(txoutput: TxOutput): number;
+export declare function get_witness_size(witness: Bytes[]): WitnessSize;