@vbyte/btc-dev 1.0.11 → 1.0.13

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export * from './class/index.js';
 export * as ADDRESS from './lib/address/index.js';
 export * as META from './lib/meta/index.js';
 export * as PSBT from './lib/psbt/index.js';

package/dist/index.js

@@ -1,4 +1,3 @@
-export * from './class/index.js';
 export * as ADDRESS from './lib/address/index.js';
 export * as META from './lib/meta/index.js';
 export * as PSBT from './lib/psbt/index.js';

package/dist/lib/sighash/segwit.d.ts

@@ -1,3 +1,6 @@
 import { Buff } from '@vbyte/buff';
-import { SigHashOptions, TxData } from '../../types/index.js';
+import { SigHashOptions, TxData, TxInput, TxOutput } from '../../types/index.js';
 export declare function hash_segwit_tx(txdata: TxData, options?: SigHashOptions): Buff;
+export declare function bip143_hash_prevouts(vin: TxInput[], isAnypay?: boolean): Uint8Array;
+export declare function bip143_hash_sequence(vin: TxInput[], sigflag: number, isAnyPay: boolean): Uint8Array;
+export declare function bip143_hash_outputs(vout: TxOutput[], sigflag: number, idx?: number): Uint8Array;

package/dist/lib/sighash/segwit.js

@@ -33,20 +33,20 @@ export function hash_segwit_tx(txdata, options = {}) {
     }
     const sighash = [
         encode_tx_version(version),
-        hash_prevouts(vin, is_anypay),
-        hash_sequence(vin, flag, is_anypay),
+        bip143_hash_prevouts(vin, is_anypay),
+        bip143_hash_sequence(vin, flag, is_anypay),
         encode_txin_txid(txid),
         encode_txin_vout(prevIdx),
         prefix_script_size(script),
         encode_vout_value(value),
         encode_txin_sequence(sequence),
-        hash_outputs(vout, flag, txindex),
+        bip143_hash_outputs(vout, flag, txindex),
         encode_tx_locktime(locktime),
         Buff.num(sigflag, 4).reverse()
     ];
     return hash256(Buff.join(sighash));
 }
-function hash_prevouts(vin, isAnypay) {
+export function bip143_hash_prevouts(vin, isAnypay) {
     if (isAnypay === true) {
         return Buff.num(0, 32);
     }
@@ -57,7 +57,7 @@ function hash_prevouts(vin, isAnypay) {
     }
     return hash256(Buff.join(stack));
 }
-function hash_sequence(vin, sigflag, isAnyPay) {
+export function bip143_hash_sequence(vin, sigflag, isAnyPay) {
     if (isAnyPay || sigflag !== 0x01) {
         return Buff.num(0, 32);
     }
@@ -67,7 +67,7 @@ function hash_sequence(vin, sigflag, isAnyPay) {
     }
     return hash256(Buff.join(stack));
 }
-function hash_outputs(vout, sigflag, idx) {
+export function bip143_hash_outputs(vout, sigflag, idx) {
     const stack = [];
     if (sigflag === 0x01) {
         for (const { value, script_pk } of vout) {

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

@@ -1,9 +1,10 @@
 import { Buff } from '@vbyte/buff';
 import type { SigHashOptions, TxData, TxInput, TxOutput } from '../../types/index.js';
 export declare function hash_taproot_tx(template: TxData | string, config?: SigHashOptions): Buff;
-export declare function hash_outpoints(vin: TxInput[]): Buff;
-export declare function hash_sequence(vin: TxInput[]): Buff;
-export declare function hash_amounts(prevouts: TxOutput[]): Buff;
-export declare function hash_scripts(prevouts: TxOutput[]): Buff;
-export declare function hash_outputs(vout: TxOutput[]): Buff;
-export declare function hash_output(vout: TxOutput): Buff;
+export declare function get_taproot_tx_preimage(template: TxData | string, config?: SigHashOptions): Buff;
+export declare function bip341_hash_outpoints(vin: TxInput[]): Buff;
+export declare function bip341_hash_sequence(vin: TxInput[]): Buff;
+export declare function bip341_hash_amounts(prevouts: TxOutput[]): Buff;
+export declare function bip341_hash_scripts(prevouts: TxOutput[]): Buff;
+export declare function bip341_hash_outputs(vout: TxOutput[]): Buff;
+export declare function bip341_hash_output(vout: TxOutput): Buff;

package/dist/lib/sighash/taproot.js

@@ -1,13 +1,16 @@
 import { Buff } from '@vbyte/buff';
 import { Assert } from '@vbyte/micro-lib';
 import { hash340, sha256 } from '@vbyte/micro-lib/hash';
-import { prefix_script_size } from '../../lib/script/util.js';
 import { encode_tapscript } from '../../lib/taproot/encode.js';
 import { parse_tx } from '../../lib/tx/parse.js';
 import * as CONST from '../../const.js';
-import { parse_txinput } from './util.js';
-import { encode_txin_vout, encode_tx_locktime, encode_txin_sequence, encode_txin_txid, encode_vout_value, encode_tx_version } from '../../lib/tx/encode.js';
+import { parse_txinput, get_annex_data, get_prevout } from './util.js';
+import { encode_txin_vout, encode_tx_locktime, encode_txin_sequence, encode_txin_txid, encode_vout_value, encode_tx_version, encode_script_data } from '../../lib/tx/encode.js';
 export function hash_taproot_tx(template, config = {}) {
+    const preimage = get_taproot_tx_preimage(template, config);
+    return hash340('TapSighash', preimage);
+}
+export function get_taproot_tx_preimage(template, config = {}) {
     const { script, txindex, sigflag = 0x00, extflag = 0x00, key_version = 0x00, separator_pos = 0xFFFFFFFF } = config;
     const tx = parse_tx(template);
     const { version, vin: input, vout: output, locktime } = tx;
@@ -28,9 +31,7 @@ export function hash_taproot_tx(template, config = {}) {
     const annexBit = (annex !== undefined) ? 1 : 0;
     const extendBit = (extension !== undefined) ? 1 : 0;
     const spendType = ((extflag + extendBit) * 2) + annexBit;
-    const hashtag = hash340('TapSighash');
     const preimage = [
-        hashtag,
         Buff.num(0x00, 1),
         Buff.num(sigflag, 1),
         encode_tx_version(version),
@@ -38,15 +39,15 @@ export function hash_taproot_tx(template, config = {}) {
     ];
     if (!is_anypay) {
         const prevouts = input.map(e => get_prevout(e));
-        preimage.push(hash_outpoints(input), hash_amounts(prevouts), hash_scripts(prevouts), hash_sequence(input));
+        preimage.push(bip341_hash_outpoints(input), bip341_hash_amounts(prevouts), bip341_hash_scripts(prevouts), bip341_hash_sequence(input));
     }
     if ((sigflag & 0x03) < 2 || (sigflag & 0x03) > 3) {
-        preimage.push(hash_outputs(output));
+        preimage.push(bip341_hash_outputs(output));
     }
     preimage.push(Buff.num(spendType, 1));
     if (is_anypay) {
         const { value, script_pk } = get_prevout(txinput);
-        preimage.push(encode_txin_txid(txid), encode_txin_vout(vout), encode_vout_value(value), prefix_script_size(script_pk), encode_txin_sequence(sequence));
+        preimage.push(encode_txin_txid(txid), encode_txin_vout(vout), encode_vout_value(value), encode_script_data(script_pk), encode_txin_sequence(sequence));
     }
     else {
         Assert.ok(typeof txindex === 'number');
@@ -57,14 +58,14 @@ export function hash_taproot_tx(template, config = {}) {
     }
     if ((sigflag & 0x03) === 0x03) {
         Assert.ok(typeof txindex === 'number');
-        preimage.push(hash_output(output[txindex]));
+        preimage.push(bip341_hash_output(output[txindex]));
     }
     if (extension !== undefined) {
-        preimage.push(Buff.bytes(extension), Buff.num(key_version), Buff.num(separator_pos, 4));
+        preimage.push(Buff.bytes(extension), Buff.num(key_version), Buff.num(separator_pos, 4, 'le'));
     }
-    return sha256(Buff.join(preimage));
+    return Buff.join(preimage);
 }
-export function hash_outpoints(vin) {
+export function bip341_hash_outpoints(vin) {
     const stack = [];
     for (const { txid, vout } of vin) {
         stack.push(encode_txin_txid(txid));
@@ -72,53 +73,23 @@ export function hash_outpoints(vin) {
     }
     return sha256(Buff.join(stack));
 }
-export function hash_sequence(vin) {
-    const stack = [];
-    for (const { sequence } of vin) {
-        stack.push(encode_txin_sequence(sequence));
-    }
-    return sha256(Buff.join(stack));
+export function bip341_hash_sequence(vin) {
+    return sha256(...vin.map(vin => encode_txin_sequence(vin.sequence)));
 }
-export function hash_amounts(prevouts) {
-    const stack = [];
-    for (const { value } of prevouts) {
-        stack.push(encode_vout_value(value));
-    }
-    return sha256(Buff.join(stack));
+export function bip341_hash_amounts(prevouts) {
+    return sha256(...prevouts.map(prevout => encode_vout_value(prevout.value)));
 }
-export function hash_scripts(prevouts) {
-    const stack = [];
-    for (const { script_pk } of prevouts) {
-        stack.push(prefix_script_size(script_pk));
-    }
-    return sha256(Buff.join(stack));
+export function bip341_hash_scripts(prevouts) {
+    return sha256(...prevouts.map(prevout => encode_script_data(prevout.script_pk)));
 }
-export function hash_outputs(vout) {
+export function bip341_hash_outputs(vout) {
     const stack = [];
     for (const { value, script_pk } of vout) {
         stack.push(encode_vout_value(value));
-        stack.push(prefix_script_size(script_pk));
-    }
-    return sha256(Buff.join(stack));
-}
-export function hash_output(vout) {
-    return sha256(encode_vout_value(vout.value), prefix_script_size(vout.script_pk));
-}
-function get_annex_data(witness) {
-    if (witness === undefined)
-        return;
-    if (witness.length < 2)
-        return;
-    const annex = witness.at(-1);
-    if (typeof annex === 'string' && annex.startsWith('50')) {
-        const bytes = Buff.hex(annex).prefix_varint('be');
-        return sha256(bytes);
+        stack.push(encode_script_data(script_pk));
     }
-    return undefined;
+    return sha256(...stack);
 }
-function get_prevout(vin) {
-    if (vin.prevout === null) {
-        throw new Error('Prevout data missing for input: ' + String(vin.txid));
-    }
-    return vin.prevout;
+export function bip341_hash_output(vout) {
+    return sha256(encode_vout_value(vout.value), encode_script_data(vout.script_pk));
 }

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

@@ -1,3 +1,5 @@
-import type { SigHashOptions, TxInput, TxData } from '../../types/index.js';
+import { Buff } from '@vbyte/buff';
+import type { SigHashOptions, TxInput, TxData, TxOutput } from '../../types/index.js';
+export declare function get_prevout(vin: TxInput): TxOutput;
 export declare function parse_txinput(txdata: TxData, config?: SigHashOptions): TxInput;
-export declare function format_sigflag(flag: number): string;
+export declare function get_annex_data(witness?: string[]): Buff | undefined;

package/dist/lib/sighash/util.js

@@ -1,5 +1,10 @@
 import { Buff } from '@vbyte/buff';
 import { Assert } from '@vbyte/micro-lib';
+import { sha256 } from '@vbyte/micro-lib/hash';
+export function get_prevout(vin) {
+    Assert.exists(vin.prevout, 'Prevout data missing for input: ' + String(vin.txid));
+    return vin.prevout;
+}
 export function parse_txinput(txdata, config) {
     let { txindex, txinput } = config ?? {};
     if (txindex !== undefined) {
@@ -11,6 +16,15 @@ export function parse_txinput(txdata, config) {
     Assert.ok(txinput !== undefined);
     return txinput;
 }
-export function format_sigflag(flag) {
-    return (flag !== 0) ? Buff.num(flag, 1).hex : '';
+export function get_annex_data(witness) {
+    if (witness === undefined)
+        return;
+    if (witness.length < 2)
+        return;
+    const annex = witness.at(-1);
+    if (typeof annex === 'string' && annex.startsWith('50')) {
+        const bytes = Buff.hex(annex).prefix_varint('be');
+        return sha256(bytes);
+    }
+    return undefined;
 }

package/dist/lib/signer/sign.js

@@ -1,20 +1,23 @@
+import { Buff } from '@vbyte/buff';
 import { ECC } from '@vbyte/micro-lib';
 import { parse_tx } from '../../lib/tx/parse.js';
 import { SIGHASH_DEFAULT } from '../../const.js';
-import { hash_segwit_tx } from '../sighash/segwit.js';
-import { hash_taproot_tx } from '../sighash/taproot.js';
-import { format_sigflag } from '../sighash/util.js';
+import { hash_segwit_tx } from '../../lib/sighash/segwit.js';
+import { hash_taproot_tx } from '../../lib/sighash/taproot.js';
 export function sign_segwit_tx(seckey, txdata, options) {
     const tx = parse_tx(txdata);
     const msg = hash_segwit_tx(tx, options);
-    const sig = ECC.sign_ecdsa(seckey, msg).hex;
+    const sig = ECC.get_ecdsa_sig(seckey, msg).hex;
     const flag = format_sigflag(options.sigflag ?? SIGHASH_DEFAULT);
     return sig + flag;
 }
 export function sign_taproot_tx(seckey, txdata, options) {
     const tx = parse_tx(txdata);
     const msg = hash_taproot_tx(tx, options);
-    const sig = ECC.sign_bip340(seckey, msg).hex;
+    const sig = ECC.get_bip340_sig(seckey, msg).hex;
     const flag = format_sigflag(options.sigflag ?? 0);
     return sig + flag;
 }
+function format_sigflag(flag) {
+    return (flag !== 0) ? Buff.num(flag, 1).hex : '';
+}

package/dist/lib/signer/verify.d.ts

@@ -1,4 +1,3 @@
 import { Bytes } from '@vbyte/buff';
 import type { SigHashOptions, TxData } from '../../types/index.js';
-export declare function verify_segwit_tx(_txdata: TxData | Bytes, _config?: SigHashOptions): boolean;
-export declare function verify_taproot_tx(_txdata: TxData | Bytes, _config?: SigHashOptions): boolean;
+export declare function verify_tx(_txdata: TxData | Bytes, _config?: SigHashOptions): boolean;

package/dist/lib/signer/verify.js

@@ -1,8 +1,4 @@
-export function verify_segwit_tx(_txdata, _config = {}) {
+export function verify_tx(_txdata, _config = {}) {
     console.warn('verify_segwit_tx is not implemented');
     return true;
 }
-export function verify_taproot_tx(_txdata, _config = {}) {
-    console.warn('verify_taproot_tx is not implemented');
-    return true;
-}

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

@@ -1,6 +1,7 @@
-import type { TxData, TxInputTemplate, TxInput, TxOutput, TxTemplate, TxSpendInput, TxCoinbaseInput } from '../../types/index.js';
-export declare function create_coinbase_input(config: TxInputTemplate | TxInput): TxCoinbaseInput;
-export declare function create_spend_input(config: TxInputTemplate | TxInput): TxSpendInput;
-export declare function create_tx_input(config: TxInputTemplate | TxInput): TxInput;
-export declare function create_tx_output(config: TxOutput): TxOutput;
-export declare function create_tx(config: TxTemplate | TxData): TxData;
+import type { TxData, TxInput, TxOutput, TxTemplate, TxSpendInput, TxCoinbaseInput, TxOutputTemplate, TxVirtualInput, TxInputTemplate } 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;
+export declare function create_tx_input(config: TxInputTemplate): TxInput;
+export declare function create_tx_output(config: TxOutputTemplate): TxOutput;
+export declare function create_tx(config?: TxTemplate): TxData;

package/dist/lib/tx/create.js

@@ -1,51 +1,49 @@
 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';
+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');
-    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 coinbase = config.coinbase;
     const witness = config.witness ?? [];
-    return { coinbase, prevout, script_sig, sequence, witness, txid, vout };
+    const sequence = normalize_sequence(config.sequence);
+    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');
+    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 };
 }
 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 };
+    const { txid, vout, script_sig = null, witness = [] } = config;
+    const prevout = normalize_prevout(config.prevout);
+    const sequence = normalize_sequence(config.sequence);
+    return { txid, vout, coinbase: null, 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)
+    if (config.coinbase)
         return create_coinbase_input(config);
-    if (prevout !== null)
+    if (config.prevout)
         return create_spend_input(config);
-    return { ...config, coinbase, prevout, script_sig, sequence, witness };
+    return create_virtual_input(config);
 }
 export function create_tx_output(config) {
-    assert_tx_output(config);
-    const { script_pk, value } = config;
-    return { script_pk, value: BigInt(value) };
+    assert_vout_template(config);
+    const script_pk = config.script_pk;
+    const value = normalize_value(config.value);
+    return { script_pk, value };
 }
 export function create_tx(config) {
     assert_tx_template(config);
-    const { vin = [], vout = [] } = 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));

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

@@ -1,9 +1,4 @@
-import { Bytes, Stream } from '@vbyte/buff';
-import { TxData, TxOutput } from '../../types/index.js';
-interface TxEncoderConfig {
-    prevouts: TxOutput[];
-    segwit: boolean;
-}
-export declare function decode_tx(txbytes: Bytes, options?: Partial<TxEncoderConfig>): TxData;
-export declare function read_script(stream: Stream, varint?: boolean): string | null;
-export {};
+import { Stream } from '@vbyte/buff';
+import { 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,20 +1,15 @@
 import { Stream } from '@vbyte/buff';
-import { Assert } from '@vbyte/micro-lib';
+import { Assert } from '@vbyte/micro-lib/assert';
 import { parse_error } from '@vbyte/micro-lib/util';
 import { COINBASE } from '../../const.js';
-const DEFAULT_CONFIG = {
-    prevouts: [],
-    segwit: true
-};
-export function decode_tx(txbytes, options = {}) {
-    const config = { ...DEFAULT_CONFIG, ...options };
-    Assert.is_bytes(txbytes, 'transaction must be hex or a byte-array');
-    const stream = new Stream(txbytes);
+export function decode_tx(txdata, use_segwit = true) {
+    Assert.is_bytes(txdata, 'txdata must be hex or bytes');
+    const stream = new Stream(txdata);
     const version = read_version(stream);
-    const has_witness = (config.segwit)
+    const has_witness = (use_segwit)
         ? check_witness_flag(stream)
         : false;
-    const vin = read_inputs(stream, config.prevouts);
+    const vin = read_inputs(stream);
     const vout = read_outputs(stream);
     if (has_witness) {
         for (const txin of vin) {
@@ -40,29 +35,26 @@ function check_witness_flag(stream) {
     }
     return false;
 }
-function read_inputs(stream, prevouts) {
+function read_inputs(stream) {
     const inputs = [];
     const vinCount = stream.varint();
     for (let i = 0; i < vinCount; i++) {
-        const txinput = read_vin(stream, prevouts.at(i));
+        const txinput = read_vin(stream);
         inputs.push(txinput);
     }
     return inputs;
 }
-function read_vin(stream, prevout = null) {
+function read_vin(stream) {
     const txid = stream.read(32).reverse().hex;
     const vout = stream.read(4).reverse().num;
-    const script_sig = read_script(stream, true);
+    const script_sig = read_payload(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 };
     }
-    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 };
+        return { coinbase: null, prevout: null, script_sig, sequence, txid, vout, witness };
     }
 }
 function read_outputs(stream) {
@@ -80,7 +72,7 @@ function read_outputs(stream) {
 }
 function read_vout(stream) {
     const value = stream.read(8).reverse().big;
-    const script_pk = read_script(stream, true);
+    const script_pk = read_payload(stream);
     Assert.exists(script_pk, 'failed to decode script_pk');
     return { value, script_pk };
 }
@@ -88,7 +80,7 @@ function read_witness(stream) {
     const stack = [];
     const count = stream.varint();
     for (let i = 0; i < count; i++) {
-        const element = read_script(stream, true);
+        const element = read_payload(stream);
         if (element === null) {
             throw new Error('failed to decode witness element: ' + i);
         }
@@ -96,13 +88,9 @@ function read_witness(stream) {
     }
     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;
+export function read_payload(stream) {
+    const size = stream.varint('le');
+    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,6 +1,6 @@
 import { Buff } from '@vbyte/buff';
 import { TxInput, TxOutput, TxData } from '../../types/index.js';
-export declare function encode_tx(txdata: TxData, segwit?: boolean): Buff;
+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;
 export declare function encode_txin_vout(vout: number): Buff;

package/dist/lib/tx/encode.js

@@ -1,17 +1,17 @@
 import { Buff } from '@vbyte/buff';
 import { Assert } from '@vbyte/micro-lib';
-import { parse_tx } from './parse.js';
+import { assert_tx_data } from './validate.js';
 import { COINBASE } from '../../const.js';
-export function encode_tx(txdata, segwit = true) {
-    const tx = parse_tx(txdata);
-    const { version, vin, vout, locktime } = tx;
+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 (segwit) {
+    if (use_segwit) {
         buffer.push(Buff.hex('0001'));
     }
     buffer.push(encode_tx_inputs(vin));
     buffer.push(encode_tx_outputs(vout));
-    if (segwit) {
+    if (use_segwit) {
         for (const input of vin) {
             buffer.push(encode_vin_witness(input.witness));
         }

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

@@ -1,2 +1,3 @@
-import type { TxData } from '../../types/index.js';
-export declare function parse_tx(txdata: unknown): TxData;
+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,12 +1,45 @@
+import { Assert } from '@vbyte/micro-lib/assert';
 import { decode_tx } from './decode.js';
-import { create_tx } from './create.js';
 import { assert_tx_template } from './validate.js';
-export function parse_tx(txdata) {
-    if (typeof txdata === 'string') {
-        return decode_tx(txdata);
+import { create_tx, create_tx_output } from './create.js';
+export function parse_tx(txdata, prevouts) {
+    let tx;
+    if (typeof txdata === 'string' || txdata instanceof Uint8Array) {
+        tx = decode_tx(txdata);
     }
     else {
         assert_tx_template(txdata);
-        return create_tx(txdata);
+        tx = create_tx(txdata);
     }
+    if (prevouts) {
+        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);
+            vin.prevout = create_tx_output(prevout);
+        }
+    }
+    return tx;
+}
+export function serialize_tx(txdata) {
+    const tx = parse_tx(txdata);
+    const version = tx.version;
+    const locktime = tx.locktime;
+    const vin = [];
+    const vout = [];
+    for (const e of tx.vin) {
+        if (e.prevout !== null) {
+            vin.push({
+                script_pk: e.prevout.script_pk,
+                value: Number(e.prevout.value)
+            });
+        }
+    }
+    for (const e of tx.vout) {
+        vout.push({
+            script_pk: e.script_pk,
+            value: Number(e.value)
+        });
+    }
+    return { version, locktime, vin, vout };
 }

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

@@ -1,8 +1,12 @@
-import type { TxData, TxOutput, TxOutputInfo, TxOutputType, TxValue, WitnessVersion } from '../../types/index.js';
+import type { TxData, TxOutput, TxOutputInfo, TxOutputTemplate, 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;
+export declare function get_txid(txdata: TxData): string;
+export declare function get_txhash(txdata: TxData): string;
+export declare function get_tx_value(txdata: TxData): TxValue;
+export declare function get_prevouts(txdata: TxData): TxOutput[];
+export declare function normalize_sequence(sequence?: number | string | null): number;
+export declare function normalize_value(value: number | bigint): bigint;
+export declare function normalize_prevout(prevout: TxOutputTemplate): TxOutput;