@vbyte/btc-dev 1.0.6 → 1.0.8

package/dist/class/tx.d.ts

@@ -1,14 +1,15 @@
 import { TransactionInput } from './txin.js';
 import { TransactionOutput } from './txout.js';
-import type { TxData, TxTemplate, TxValue, TransactionData } from '../types/index.js';
+import type { TxData, TxTemplate, TransactionData, TxOutput, TxSize, TxValue, TxInputTemplate } from '../types/index.js';
 export declare class Transaction {
-    private readonly _size;
     private readonly _tx;
-    private readonly _hash;
-    private readonly _value;
-    private readonly _vin;
-    private readonly _vout;
-    constructor(txdata: string | TxData | TxTemplate);
+    private _size;
+    private _hash;
+    private _txid;
+    private _value;
+    private _vin;
+    private _vout;
+    constructor(txdata?: string | TxData | TxTemplate);
     get data(): TransactionData;
     get hash(): string;
     get locktime(): {
@@ -16,16 +17,9 @@ export declare class Transaction {
         data: import("../types/index.js").LocktimeData | null;
         value: number;
     };
-    get return(): import("../types/index.js").TxOutput | null;
-    get size(): {
+    get return(): TxOutput | null;
+    get size(): TxSize & {
         segwit: number;
-        vin: number;
-        vout: number;
-        witness: number;
-        base: number;
-        real: number;
-        weight: number;
-        vsize: number;
     };
     get spends(): TransactionOutput[];
     get txid(): string;
@@ -33,6 +27,25 @@ export declare class Transaction {
     get version(): number;
     get vin(): TransactionInput[];
     get vout(): TransactionOutput[];
+    add_vin(tx_input: TxInputTemplate): void;
+    add_vout(tx_output: TxOutput): void;
+    insert_vin(index: number, tx_input: TxInputTemplate): void;
+    insert_vout(index: number, tx_output: TxOutput): void;
+    remove_vin(index: number): void;
+    remove_vout(index: number): void;
+    _get_size(): {
+        segwit: number;
+        vin: number;
+        vout: number;
+        witness: number;
+        base: number;
+        total: number;
+        weight: number;
+        vsize: number;
+    };
+    _update_tx(): void;
+    _update_vin(): void;
+    _update_vout(): void;
     toJSON(): TransactionData;
     toString(): string;
 }

package/dist/class/tx.js

@@ -1,17 +1,19 @@
+import { Assert } from '@vbyte/micro-lib';
 import { LocktimeUtil } from '../lib/meta/index.js';
 import { TransactionInput } from './txin.js';
 import { TransactionOutput } from './txout.js';
-import { decode_tx, get_txid, is_return_script, parse_tx, get_txsize, get_tx_value, get_txhash, encode_tx_locktime, } from '../lib/tx/index.js';
+import { decode_tx, get_txid, is_return_script, parse_tx, get_txsize, get_tx_value, get_txhash, encode_tx_locktime, create_tx_input, create_tx_output, } from '../lib/tx/index.js';
 export class Transaction {
-    constructor(txdata) {
+    constructor(txdata = {}) {
         this._tx = (typeof txdata !== 'string')
             ? parse_tx(txdata)
             : decode_tx(txdata);
-        this._vin = this._tx.vin.map(txin => new TransactionInput(txin));
-        this._vout = this._tx.vout.map(txout => new TransactionOutput(txout));
-        this._size = get_txsize(this._tx);
+        this._size = this._get_size();
         this._hash = get_txhash(this._tx);
+        this._txid = get_txid(this._tx);
         this._value = get_tx_value(this._tx);
+        this._vin = this._tx.vin.map(txin => new TransactionInput(txin));
+        this._vout = this._tx.vout.map(txout => new TransactionOutput(txout));
     }
     get data() {
         return {
@@ -41,13 +43,7 @@ export class Transaction {
         return this._tx.vout.find(txout => is_return_script(txout.script_pk)) || null;
     }
     get size() {
-        return {
-            ...this._size,
-            segwit: this._vin.reduce((acc, txin) => acc + (txin.witness?.vsize ?? 0), 0),
-            vin: this._vin.reduce((acc, txin) => acc + txin.size, 0),
-            vout: this._vout.reduce((acc, txout) => acc + txout.size, 0),
-            witness: this._vin.reduce((acc, txin) => acc + (txin.witness?.size ?? 0), 0)
-        };
+        return this._size;
     }
     get spends() {
         return this._tx.vin
@@ -55,7 +51,7 @@ export class Transaction {
             .map(txin => new TransactionOutput(txin.prevout));
     }
     get txid() {
-        return get_txid(this._tx);
+        return this._txid;
     }
     get value() {
         return this._value;
@@ -69,6 +65,71 @@ export class Transaction {
     get vout() {
         return this._vout;
     }
+    add_vin(tx_input) {
+        const txin = create_tx_input(tx_input);
+        this._tx.vin.push(txin);
+        this._update_vin();
+    }
+    add_vout(tx_output) {
+        const txout = create_tx_output(tx_output);
+        this._tx.vout.push(txout);
+        this._update_vout();
+    }
+    insert_vin(index, tx_input) {
+        Assert.ok(index >= 0 && index <= this._tx.vin.length, 'input goes out of bounds');
+        const txin = create_tx_input(tx_input);
+        if (index === this._tx.vin.length) {
+            this._tx.vin.push(txin);
+        }
+        else {
+            this._tx.vin.splice(index, 0, txin);
+        }
+        this._update_vin();
+    }
+    insert_vout(index, tx_output) {
+        Assert.ok(index >= 0 && index <= this._tx.vout.length, 'output goes out of bounds');
+        const txout = create_tx_output(tx_output);
+        if (index === this._tx.vout.length) {
+            this._tx.vout.push(txout);
+        }
+        else {
+            this._tx.vout.splice(index, 0, txout);
+        }
+        this._update_vout();
+    }
+    remove_vin(index) {
+        Assert.ok(this._tx.vin.at(index) !== undefined, 'input does not exist at index');
+        this._tx.vin.splice(index, 1);
+        this._update_vin();
+    }
+    remove_vout(index) {
+        Assert.ok(this._tx.vout.at(index) !== undefined, 'output does not exist at index');
+        this._tx.vout.splice(index, 1);
+        this._update_vout();
+    }
+    _get_size() {
+        return {
+            ...get_txsize(this._tx),
+            segwit: this.vin.reduce((acc, txin) => acc + (txin.witness?.size.vsize ?? 0), 0),
+            vin: this.vin.reduce((acc, txin) => acc + txin.size, 0),
+            vout: this.vout.reduce((acc, txout) => acc + txout.size, 0),
+            witness: this.vin.reduce((acc, txin) => acc + (txin.witness?.size.total ?? 0), 0)
+        };
+    }
+    _update_tx() {
+        this._size = this._get_size();
+        this._hash = get_txhash(this._tx);
+        this._txid = get_txid(this._tx);
+        this._value = get_tx_value(this._tx);
+    }
+    _update_vin() {
+        this._vin = this._tx.vin.map(txin => new TransactionInput(txin));
+        this._update_tx();
+    }
+    _update_vout() {
+        this._vout = this._tx.vout.map(txout => new TransactionOutput(txout));
+        this._update_tx();
+    }
     toJSON() { return this.data; }
     toString() { return JSON.stringify(this.data); }
 }

package/dist/class/txin.d.ts

@@ -2,9 +2,7 @@ import { TransactionOutput } from './txout.js';
 import { TransactionWitness } from './witness.js';
 import type { TxInput, TransactionInputData } from '../types/index.js';
 export declare class TransactionInput {
-    private readonly _size;
     private readonly _txin;
-    private readonly _witness;
     constructor(txin: TxInput);
     get coinbase(): string | null;
     get data(): TransactionInputData;

package/dist/class/txin.js

@@ -5,11 +5,7 @@ import { TransactionWitness } from './witness.js';
 import { encode_txin_sequence, get_txin_size, } from '../lib/tx/index.js';
 export class TransactionInput {
     constructor(txin) {
-        this._size = get_txin_size(txin);
         this._txin = txin;
-        this._witness = txin.witness.length > 0
-            ? new TransactionWitness(txin.witness)
-            : null;
     }
     get coinbase() {
         return this._txin.coinbase;
@@ -53,7 +49,7 @@ export class TransactionInput {
         };
     }
     get size() {
-        return this._size;
+        return get_txin_size(this._txin);
     }
     get txid() {
         return this._txin.txid;
@@ -62,7 +58,9 @@ export class TransactionInput {
         return this._txin.vout;
     }
     get witness() {
-        return this._witness;
+        return this._txin.witness.length > 0
+            ? new TransactionWitness(this._txin.witness)
+            : null;
     }
     toJSON() { return this.data; }
     toString() { return JSON.stringify(this.data); }

package/dist/class/txout.d.ts

@@ -1,7 +1,5 @@
 import type { TxOutput, TransactionOutputData } from '../types/index.js';
 export declare class TransactionOutput {
-    private readonly _info;
-    private readonly _size;
     private readonly _txout;
     constructor(txout: TxOutput);
     get data(): TransactionOutputData;

package/dist/class/txout.js

@@ -1,9 +1,7 @@
 import { decode_script } from '../lib/script/index.js';
-import { get_txout_size, get_vout_info } from '../lib/tx/index.js';
+import { get_txout_size, get_vout_type, get_vout_version } from '../lib/tx/index.js';
 export class TransactionOutput {
     constructor(txout) {
-        this._info = get_vout_info(txout);
-        this._size = get_txout_size(txout);
         this._txout = txout;
     }
     get data() {
@@ -22,16 +20,16 @@ export class TransactionOutput {
         };
     }
     get size() {
-        return this._size;
+        return get_txout_size(this._txout);
     }
     get type() {
-        return this._info.type;
+        return get_vout_type(this._txout.script_pk);
     }
     get value() {
         return this._txout.value;
     }
     get version() {
-        return this._info.version;
+        return get_vout_version(this._txout.script_pk);
     }
     toJSON() { return this.data; }
     toString() { return JSON.stringify(this.data); }

package/dist/class/witness.d.ts

@@ -1,20 +1,23 @@
 import { Bytes } from '@vbyte/buff';
-import type { ScriptField, WitnessField, WitnessType } from '../types/index.js';
+import type { ScriptField, WitnessData, WitnessSize, WitnessType } from '../types/index.js';
 export declare class TransactionWitness {
-    private readonly _data;
-    private readonly _meta;
-    private readonly _size;
+    private readonly _elems;
+    private _data;
+    private _size;
     constructor(witness: Bytes[]);
     get annex(): string | null;
     get cblock(): string | null;
-    get data(): WitnessField;
+    get data(): WitnessData;
     get params(): string[];
     get script(): ScriptField | null;
-    get size(): number;
+    get size(): WitnessSize;
     get stack(): string[];
     get type(): WitnessType;
     get version(): number | null;
-    get vsize(): number;
-    toJSON(): WitnessField;
+    _update(): void;
+    add(elem: Bytes): void;
+    insert(index: number, elem: Bytes): void;
+    remove(index: number): void;
+    toJSON(): WitnessData;
     toString(): string;
 }

package/dist/class/witness.js

@@ -1,56 +1,66 @@
 import { Buff } from '@vbyte/buff';
+import { Assert } from '@vbyte/micro-lib';
 import { decode_script } from '../lib/script/index.js';
-import { parse_witness_data, get_witness_size, } from '../lib/witness/index.js';
+import { parse_witness, get_witness_size, } from '../lib/witness/index.js';
 export class TransactionWitness {
     constructor(witness) {
-        this._data = witness.map(e => Buff.bytes(e));
-        this._meta = parse_witness_data(witness);
-        this._size = get_witness_size(witness);
+        this._elems = witness.map(e => Buff.bytes(e));
+        this._data = parse_witness(this._elems);
+        this._size = get_witness_size(this._elems);
     }
     get annex() {
-        return this._meta.annex;
+        return this._data.annex;
     }
     get cblock() {
-        return this._meta.cblock;
+        return this._data.cblock;
     }
     get data() {
-        return {
-            annex: this.annex,
-            cblock: this.cblock,
-            params: this.params,
-            script: this.script,
-            size: this.size,
-            stack: this.stack,
-            type: this.type,
-            version: this.version,
-            vsize: this.vsize
-        };
+        return this._data;
     }
     get params() {
-        return this._meta.params;
+        return this._data.params;
     }
     get script() {
-        if (this._meta.script === null)
+        if (this._data.script === null)
             return null;
         return {
-            hex: this._meta.script,
-            asm: decode_script(this._meta.script)
+            hex: this._data.script,
+            asm: decode_script(this._data.script)
         };
     }
     get size() {
-        return this._size.size;
+        return this._size;
     }
     get stack() {
-        return this._data.map(e => e.hex);
+        return this._elems.map(e => e.hex);
     }
     get type() {
-        return this._meta.type;
+        return this._data.type;
     }
     get version() {
-        return this._meta.version;
+        return this._data.version;
+    }
+    _update() {
+        this._data = parse_witness(this._elems);
+        this._size = get_witness_size(this._elems);
+    }
+    add(elem) {
+        this._elems.push(Buff.bytes(elem));
+        this._update();
+    }
+    insert(index, elem) {
+        Assert.ok(index >= 0 && index <= this._elems.length, 'index out of bounds');
+        if (index === this._elems.length) {
+            this._elems.push(Buff.bytes(elem));
+        }
+        else {
+            this._elems.splice(index, 0, Buff.bytes(elem));
+        }
+        this._update();
     }
-    get vsize() {
-        return this._size.vsize;
+    remove(index) {
+        this._elems.splice(index, 1);
+        this._update();
     }
     toJSON() { return this.data; }
     toString() { return JSON.stringify(this.data); }

package/dist/lib/taproot/parse.js

@@ -1,9 +1,9 @@
 import { Buff, Stream } from '@vbyte/buff';
 import { Assert, ECC } from '@vbyte/micro-lib';
-import { parse_witness_data } from '../../lib/witness/parse.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_data(witness);
+    const { cblock, params, script } = parse_witness(witness);
     Assert.exists(cblock, 'cblock is null');
     Assert.exists(script, 'script is null');
     const cblk = parse_cblock(cblock);

package/dist/lib/tx/size.js

@@ -10,11 +10,11 @@ export function get_vsize(bytes) {
 export function get_txsize(txdata) {
     const json = parse_tx(txdata);
     const base = encode_tx(json, false).length;
-    const size = encode_tx(json, true).length;
-    const weight = base * 3 + size;
+    const total = encode_tx(json, true).length;
+    const weight = base * 3 + total;
     const remain = (weight % 4 > 0) ? 1 : 0;
     const vsize = Math.floor(weight / 4) + remain;
-    return { base, real: size, vsize, weight };
+    return { base, total, vsize, weight };
 }
 export function get_vin_size(vin) {
     const bytes = encode_tx_inputs(vin);

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

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

package/dist/lib/witness/parse.js

@@ -1,8 +1,9 @@
 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) {
+export function parse_witness(witness) {
     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,7 +16,7 @@ export function parse_witness_data(witness) {
     if (script !== null)
         elems.pop();
     const params = elems.map(e => e.hex);
-    return { annex, cblock, params, script, type, version };
+    return { annex, cblock, params, script, stack, type, version };
 }
 function parse_annex_data(data) {
     let elem = data.at(-1);

package/dist/lib/witness/util.js

@@ -4,5 +4,5 @@ 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 };
+    return { total: size, vsize };
 }