@vbyte/btc-dev 1.0.6 → 1.0.8

package/dist/main.cjs

@@ -9159,11 +9159,11 @@ function get_vsize$1(bytes) {
 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 };
 }
 function get_vin_size(vin) {
     const bytes = encode_tx_inputs(vin);
@@ -9879,8 +9879,6 @@ var index$6 = /*#__PURE__*/Object.freeze({
 
 class TransactionOutput {
     constructor(txout) {
-        this._info = get_vout_info(txout);
-        this._size = get_txout_size(txout);
         this._txout = txout;
     }
     get data() {
@@ -9899,23 +9897,24 @@ 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); }
 }
 
-function parse_witness_data(witness) {
+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();
@@ -9928,7 +9927,7 @@ 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);
@@ -10002,65 +10001,74 @@ 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 };
 }
 
 var index$5 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get_witness_size: get_witness_size,
-    parse_witness_data: parse_witness_data
+    parse_witness: parse_witness
 });
 
 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;
     }
-    get vsize() {
-        return this._size.vsize;
+    _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();
+    }
+    remove(index) {
+        this._elems.splice(index, 1);
+        this._update();
     }
     toJSON() { return this.data; }
     toString() { return JSON.stringify(this.data); }
@@ -10068,11 +10076,7 @@ class TransactionWitness {
 
 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;
@@ -10116,7 +10120,7 @@ class TransactionInput {
         };
     }
     get size() {
-        return this._size;
+        return get_txin_size(this._txin);
     }
     get txid() {
         return this._txin.txid;
@@ -10125,22 +10129,25 @@ 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); }
 }
 
 let Transaction$1 = 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 {
@@ -10170,13 +10177,7 @@ let Transaction$1 = 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
@@ -10184,7 +10185,7 @@ let Transaction$1 = class Transaction {
             .map(txin => new TransactionOutput(txin.prevout));
     }
     get txid() {
-        return get_txid(this._tx);
+        return this._txid;
     }
     get value() {
         return this._value;
@@ -10198,6 +10199,71 @@ let Transaction$1 = 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); }
 };
@@ -14519,7 +14585,7 @@ function merkleize(taptree, target, path = []) {
 }
 
 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);