@vbyte/btc-dev 1.0.10 → 1.0.11

package/dist/module.mjs

@@ -9877,36 +9877,6 @@ var index$6 = /*#__PURE__*/Object.freeze({
     encode_sequence: encode_sequence
 });
 
-class TransactionOutput {
-    constructor(txout) {
-        assert_tx_output(txout);
-        this._txout = txout;
-    }
-    get data() {
-        return this._txout;
-    }
-    get script_pk() {
-        return {
-            hex: this._txout.script_pk,
-            asm: decode_script(this._txout.script_pk)
-        };
-    }
-    get size() {
-        return get_txout_size(this._txout);
-    }
-    get type() {
-        return get_vout_type(this._txout.script_pk);
-    }
-    get value() {
-        return this._txout.value;
-    }
-    get version() {
-        return get_vout_version(this._txout.script_pk);
-    }
-    toJSON() { return this.data; }
-    toString() { return JSON.stringify(this.data); }
-}
-
 function parse_witness(witness) {
     const elems = witness.map(e => Buff.bytes(e));
     const stack = witness.map(e => Buff.bytes(e).hex);
@@ -10011,140 +9981,151 @@ var index$5 = /*#__PURE__*/Object.freeze({
 });
 
 class TransactionWitness {
-    constructor(witness) {
-        assert_witness(witness);
-        this._elems = witness.map(e => Buff.bytes(e));
-        this._data = parse_witness(this._elems);
-        this._size = get_witness_size(this._elems);
+    constructor(transaction, index) {
+        this._tx = transaction;
+        this._index = index;
     }
     get annex() {
-        return this._data.annex;
+        return this.data.annex;
     }
     get cblock() {
-        return this._data.cblock;
+        return this.data.cblock;
     }
     get data() {
-        return this._data;
+        return parse_witness(this.stack);
     }
     get params() {
-        return this._data.params;
+        return this.data.params;
     }
     get script() {
-        if (this._data.script === null)
+        if (this.data.script === null)
             return null;
         return {
-            hex: this._data.script,
-            asm: decode_script(this._data.script)
+            hex: this.data.script,
+            asm: decode_script(this.data.script)
         };
     }
     get size() {
-        return this._size;
+        return get_witness_size(this.stack);
     }
     get stack() {
-        return this._elems.map(e => e.hex);
+        const txin = this._tx.data.vin.at(this._index);
+        Assert.exists(txin, 'txin not found at index ' + this._index);
+        Assert.exists(txin.witness, 'witness not found at index ' + this._index);
+        return txin.witness;
     }
     get type() {
-        return this._data.type;
+        return this.data.type;
     }
     get 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();
-    }
-    remove(index) {
-        this._elems.splice(index, 1);
-        this._update();
+        return this.data.version;
     }
     toJSON() { return this.data; }
     toString() { return JSON.stringify(this.data); }
 }
 
 class TransactionInput {
-    constructor(txin) {
-        assert_tx_input(txin);
-        this._txin = txin;
+    constructor(transaction, index) {
+        this._tx = transaction;
+        this._index = index;
     }
     get coinbase() {
-        return this._txin.coinbase;
+        return this.data.coinbase;
     }
     get data() {
-        return this._txin;
+        const txin = this._tx.data.vin.at(this.index);
+        Assert.exists(txin, 'txin not found');
+        return txin;
     }
     get has_prevout() {
-        return this._txin.prevout !== null;
+        return this.data.prevout !== null;
+    }
+    get index() {
+        return this._index;
     }
     get is_coinbase() {
-        return this._txin.coinbase !== null;
+        return this.data.coinbase !== null;
     }
     get prevout() {
-        return this._txin.prevout
-            ? new TransactionOutput(this._txin.prevout)
-            : null;
+        return this.data.prevout;
     }
     get script_sig() {
-        if (this._txin.script_sig === null)
+        if (this.data.script_sig === null)
             return null;
         return {
-            asm: decode_script(this._txin.script_sig),
-            hex: this._txin.script_sig
+            asm: decode_script(this.data.script_sig),
+            hex: this.data.script_sig
         };
     }
     get sequence() {
         return {
-            hex: encode_txin_sequence(this._txin.sequence).hex,
-            data: SequenceUtil.decode(this._txin.sequence),
-            value: this._txin.sequence
+            hex: encode_txin_sequence(this.data.sequence).hex,
+            data: SequenceUtil.decode(this.data.sequence),
+            value: this.data.sequence
         };
     }
     get size() {
-        return get_txin_size(this._txin);
+        return get_txin_size(this.data);
     }
     get txid() {
-        return this._txin.txid;
+        return this.data.txid;
     }
     get vout() {
-        return this._txin.vout;
+        return this.data.vout;
     }
     get witness() {
-        return this._txin.witness.length > 0
-            ? new TransactionWitness(this._txin.witness)
+        return this.data.witness.length > 0
+            ? new TransactionWitness(this._tx, this.index)
             : null;
     }
     toJSON() { return this.data; }
     toString() { return JSON.stringify(this.data); }
 }
 
+class TransactionOutput {
+    constructor(transaction, index) {
+        this._tx = transaction;
+        this._index = index;
+    }
+    get data() {
+        const txout = this._tx.data.vout.at(this.index);
+        Assert.exists(txout, 'txout not found');
+        return txout;
+    }
+    get index() {
+        return this._index;
+    }
+    get script_pk() {
+        return {
+            hex: this.data.script_pk,
+            asm: decode_script(this.data.script_pk)
+        };
+    }
+    get size() {
+        return get_txout_size(this.data);
+    }
+    get type() {
+        return get_vout_type(this.data.script_pk);
+    }
+    get value() {
+        return this.data.value;
+    }
+    get version() {
+        return get_vout_version(this.data.script_pk);
+    }
+    toJSON() { return this.data; }
+    toString() { return JSON.stringify(this.data); }
+}
+
 let Transaction$1 = class Transaction {
     constructor(txdata = {}) {
         this._tx = parse_tx(txdata);
-        this._vin = this._tx.vin.map(txin => new TransactionInput(txin));
-        this._vout = this._tx.vout.map(txout => new TransactionOutput(txout));
-        this._size = this._get_size();
-        this._hash = get_txhash(this._tx);
-        this._txid = get_txid(this._tx);
-        this._value = get_tx_value(this._tx);
     }
     get data() {
         return this._tx;
     }
     get hash() {
-        return this._hash;
+        return get_txhash(this._tx);
     }
     get locktime() {
         return {
@@ -10157,37 +10138,35 @@ let Transaction$1 = class Transaction {
         return this._tx.vout.find(txout => is_return_script(txout.script_pk)) || null;
     }
     get size() {
-        return this._size;
+        return get_txsize(this._tx);
     }
     get spends() {
         return this._tx.vin
             .filter(txin => txin.prevout !== null)
-            .map(txin => new TransactionOutput(txin.prevout));
+            .map(txin => txin.prevout);
     }
     get txid() {
-        return this._txid;
+        return get_txid(this._tx);
     }
     get value() {
-        return this._value;
+        return get_tx_value(this._tx);
     }
     get version() {
         return this._tx.version;
     }
     get vin() {
-        return this._vin;
+        return this._tx.vin.map((_, idx) => new TransactionInput(this, idx));
     }
     get vout() {
-        return this._vout;
+        return this._tx.vout.map((_, idx) => new TransactionOutput(this, idx));
     }
     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');
@@ -10198,7 +10177,6 @@ let Transaction$1 = class Transaction {
         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');
@@ -10209,17 +10187,14 @@ let Transaction$1 = class Transaction {
         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 {
@@ -10230,20 +10205,6 @@ let Transaction$1 = class Transaction {
             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); }
 };