@vbyte/btc-dev 1.0.9 → 1.0.11

package/dist/class/signer.js

@@ -1,8 +1,10 @@
 import { Buff } from '@vbyte/buff';
-import { ECC } from '@vbyte/micro-lib';
+import { Assert, ECC } from '@vbyte/micro-lib';
 import { sign_segwit_tx, sign_taproot_tx } from '../lib/signer/sign.js';
 export 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() {

package/dist/class/tx.d.ts

@@ -1,14 +1,8 @@
 import { TransactionInput } from './txin.js';
 import { TransactionOutput } from './txout.js';
-import type { TxData, TxTemplate, TxOutput, TxSize, TxValue, TxInputTemplate } from '../types/index.js';
+import type { TxData, TxTemplate, TxOutput, TxInputTemplate } from '../types/index.js';
 export declare class Transaction {
     private readonly _tx;
-    private _size;
-    private _hash;
-    private _txid;
-    private _value;
-    private _vin;
-    private _vout;
     constructor(txdata?: string | TxData | TxTemplate);
     get data(): TxData;
     get hash(): string;
@@ -18,12 +12,10 @@ export declare class Transaction {
         value: number;
     };
     get return(): TxOutput | null;
-    get size(): TxSize & {
-        segwit: number;
-    };
-    get spends(): TransactionOutput[];
+    get size(): import("../types/index.js").TxSize;
+    get spends(): TxOutput[];
     get txid(): string;
-    get value(): TxValue;
+    get value(): import("../types/index.js").TxValue;
     get version(): number;
     get vin(): TransactionInput[];
     get vout(): TransactionOutput[];
@@ -43,9 +35,6 @@ export declare class Transaction {
         vsize: number;
         weight: number;
     };
-    _update_tx(): void;
-    _update_vin(): void;
-    _update_vout(): void;
     toJSON(): TxData;
     toString(): string;
 }

package/dist/class/tx.js

@@ -2,24 +2,16 @@ 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, create_tx_input, create_tx_output, } from '../lib/tx/index.js';
+import { 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 = {}) {
-        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 {
@@ -32,37 +24,35 @@ export 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');
@@ -73,7 +63,6 @@ export 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');
@@ -84,17 +73,14 @@ export 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 {
@@ -105,20 +91,6 @@ export 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); }
 }

package/dist/class/txin.d.ts

@@ -1,14 +1,16 @@
-import { TransactionOutput } from './txout.js';
+import { Transaction } from './tx.js';
 import { TransactionWitness } from './witness.js';
-import type { TxInput } from '../types/index.js';
+import type { TxInput, TxOutput } from '../types/index.js';
 export declare class TransactionInput {
-    private readonly _txin;
-    constructor(txin: TxInput);
+    private readonly _tx;
+    private readonly _index;
+    constructor(transaction: Transaction, index: number);
     get coinbase(): string | null;
     get data(): TxInput;
     get has_prevout(): boolean;
+    get index(): number;
     get is_coinbase(): boolean;
-    get prevout(): TransactionOutput | null;
+    get prevout(): TxOutput | null;
     get script_sig(): {
         asm: string[];
         hex: string;

package/dist/class/txin.js

@@ -1,56 +1,60 @@
+import { Assert } from '@vbyte/micro-lib';
 import { decode_script } from '../lib/script/index.js';
 import { SequenceUtil } from '../lib/meta/index.js';
-import { TransactionOutput } from './txout.js';
 import { TransactionWitness } from './witness.js';
 import { encode_txin_sequence, get_txin_size, } from '../lib/tx/index.js';
 export 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; }

package/dist/class/txout.d.ts

@@ -1,8 +1,11 @@
+import { Transaction } from './tx.js';
 import type { TxOutput } from '../types/index.js';
 export declare class TransactionOutput {
-    private readonly _txout;
-    constructor(txout: TxOutput);
+    private readonly _tx;
+    private readonly _index;
+    constructor(transaction: Transaction, index: number);
     get data(): TxOutput;
+    get index(): number;
     get script_pk(): {
         hex: string;
         asm: string[];

package/dist/class/txout.js

@@ -1,29 +1,36 @@
+import { Assert } from '@vbyte/micro-lib';
 import { decode_script } from '../lib/script/index.js';
 import { get_txout_size, get_vout_type, get_vout_version } from '../lib/tx/index.js';
 export class TransactionOutput {
-    constructor(txout) {
-        this._txout = txout;
+    constructor(transaction, index) {
+        this._tx = transaction;
+        this._index = index;
     }
     get data() {
-        return this._txout;
+        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._txout.script_pk,
-            asm: decode_script(this._txout.script_pk)
+            hex: this.data.script_pk,
+            asm: decode_script(this.data.script_pk)
         };
     }
     get size() {
-        return get_txout_size(this._txout);
+        return get_txout_size(this.data);
     }
     get type() {
-        return get_vout_type(this._txout.script_pk);
+        return get_vout_type(this.data.script_pk);
     }
     get value() {
-        return this._txout.value;
+        return this.data.value;
     }
     get version() {
-        return get_vout_version(this._txout.script_pk);
+        return get_vout_version(this.data.script_pk);
     }
     toJSON() { return this.data; }
     toString() { return JSON.stringify(this.data); }

package/dist/class/witness.d.ts

@@ -1,10 +1,9 @@
-import { Bytes } from '@vbyte/buff';
+import { Transaction } from './tx.js';
 import type { ScriptField, WitnessData, WitnessSize, WitnessType } from '../types/index.js';
 export declare class TransactionWitness {
-    private readonly _elems;
-    private _data;
-    private _size;
-    constructor(witness: Bytes[]);
+    private readonly _tx;
+    private readonly _index;
+    constructor(transaction: Transaction, index: number);
     get annex(): string | null;
     get cblock(): string | null;
     get data(): WitnessData;
@@ -14,10 +13,6 @@ export declare class TransactionWitness {
     get stack(): string[];
     get type(): WitnessType;
     get version(): number | null;
-    _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,66 +1,45 @@
-import { Buff } from '@vbyte/buff';
 import { Assert } from '@vbyte/micro-lib';
 import { decode_script } from '../lib/script/index.js';
-import { parse_witness, 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._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); }

package/dist/lib/tx/decode.js

@@ -8,7 +8,7 @@ const DEFAULT_CONFIG = {
 };
 export 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)

package/dist/lib/tx/size.js

@@ -5,7 +5,7 @@ const WIT_FLAG_BYTES = 2;
 export function get_vsize(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;
 }
 export function get_txsize(txdata) {
     const json = parse_tx(txdata);
@@ -13,7 +13,7 @@ export 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 };
 }
 export function get_vin_size(vin) {

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

@@ -1,3 +1,4 @@
 import { Bytes } from '@vbyte/buff';
 import type { WitnessSize } from '../../types/index.js';
 export declare function get_witness_size(witness: Bytes[]): WitnessSize;
+export declare function assert_witness(witness: unknown): asserts witness is Bytes[];

package/dist/lib/witness/util.js

@@ -1,4 +1,5 @@
 import { Buff } from '@vbyte/buff';
+import { Assert } from '@vbyte/micro-lib';
 const WIT_LENGTH_BYTE = 1;
 export function get_witness_size(witness) {
     const stack = witness.map(e => Buff.bytes(e));
@@ -6,3 +7,7 @@ export function get_witness_size(witness) {
     const vsize = Math.ceil(WIT_LENGTH_BYTE + size / 4);
     return { total: size, vsize };
 }
+export 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');
+}