@vbyte/btc-dev 1.0.9 → 1.0.11

package/dist/main.cjs

@@ -8415,7 +8415,7 @@ const DEFAULT_CONFIG = {
 };
 function decode_tx(txbytes, options = {}) {
     const config = { ...DEFAULT_CONFIG, ...options };
-    Assert.is_bytes(txbytes, 'txbytes must be hex or a unit array');
+    Assert.is_bytes(txbytes, 'transaction must be hex or a byte-array');
     const stream = new Stream(txbytes);
     const version = read_version(stream);
     const has_witness = (config.segwit)
@@ -9154,7 +9154,7 @@ const WIT_FLAG_BYTES = 2;
 function get_vsize$1(bytes) {
     const weight = Buff.bytes(bytes).length;
     const remain = (weight % 4 > 0) ? 1 : 0;
-    return Math.floor(weight / 4) + remain;
+    return Math.ceil(weight / 4) + remain;
 }
 function get_txsize(txdata) {
     const json = parse_tx(txdata);
@@ -9162,7 +9162,7 @@ function get_txsize(txdata) {
     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;
+    const vsize = Math.ceil(weight / 4) + remain;
     return { base, total, vsize, weight };
 }
 function get_vin_size(vin) {
@@ -9473,6 +9473,8 @@ function sign_taproot_tx(seckey, txdata, options) {
 
 class TxSigner {
     constructor(seckey) {
+        Assert.ok(Buff.is_bytes(seckey), 'seckey must be a string or bytes');
+        Assert.size(seckey, 32, 'seckey must be 32 bytes');
         this._seckey = Buff.bytes(seckey).hex;
     }
     get pubkey() {
@@ -9877,35 +9879,6 @@ var index$6 = /*#__PURE__*/Object.freeze({
     encode_sequence: encode_sequence
 });
 
-class TransactionOutput {
-    constructor(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);
@@ -9997,148 +9970,164 @@ function get_witness_size(witness) {
     const vsize = Math.ceil(WIT_LENGTH_BYTE + size / 4);
     return { total: size, vsize };
 }
+function assert_witness(witness) {
+    Assert.ok(Array.isArray(witness), 'witness must be an array');
+    Assert.ok(witness.every(e => Buff.is_bytes(e)), 'witness must be an array of strings or bytes');
+}
 
 var index$5 = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    assert_witness: assert_witness,
     get_witness_size: get_witness_size,
     parse_witness: parse_witness
 });
 
 class TransactionWitness {
-    constructor(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) {
-        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 = (typeof txdata !== 'string')
-            ? parse_tx(txdata)
-            : decode_tx(txdata);
-        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));
+        this._tx = parse_tx(txdata);
     }
     get data() {
         return this._tx;
     }
     get hash() {
-        return this._hash;
+        return get_txhash(this._tx);
     }
     get locktime() {
         return {
@@ -10151,37 +10140,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');
@@ -10192,7 +10179,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');
@@ -10203,17 +10189,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 {
@@ -10224,20 +10207,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); }
 };