@vbyte/btc-dev 1.0.10 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vbyte/btc-dev",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Batteries-included toolset for plebian bitcoin development",
   "type": "module",
   "keywords": [

package/src/class/tx.ts

@@ -20,8 +20,6 @@ import type {
   TxData,
   TxTemplate,
   TxOutput,
-  TxSize,
-  TxValue,
   TxInputTemplate
 } from '@/types/index.js'
 
@@ -29,22 +27,8 @@ export class Transaction {
 
   private readonly _tx : TxData
 
-  private _size  : TxSize & { segwit : number }
-  private _hash  : string
-  private _txid  : string
-  private _value : TxValue
-  private _vin   : TransactionInput[]
-  private _vout  : TransactionOutput[]
-
   constructor (txdata : string | TxData | TxTemplate = {}) {
-    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)
+    this._tx = parse_tx(txdata)
   }
 
   get data () : TxData {
@@ -52,7 +36,7 @@ export class Transaction {
   }
 
   get hash () : string {
-    return this._hash
+    return get_txhash(this._tx)
   }
 
   get locktime () {
@@ -68,21 +52,21 @@ export class Transaction {
   }
 
   get size () {
-    return this._size
+    return get_txsize(this._tx)
   }
 
-  get spends () : TransactionOutput[] {
+  get spends () : TxOutput[] {
     return this._tx.vin
       .filter(txin => txin.prevout !== null)
-      .map(txin => new TransactionOutput(txin.prevout!))
+      .map(txin => txin.prevout!)
   }
 
   get txid () : string {
-    return this._txid
+    return get_txid(this._tx)
   }
 
   get value () {
-    return this._value
+    return get_tx_value(this._tx)
   }
 
   get version () : number {
@@ -90,23 +74,21 @@ export class Transaction {
   }
 
   get vin () : TransactionInput[] {
-    return this._vin
+    return this._tx.vin.map((_, idx) => new TransactionInput(this, idx))
   }
 
   get vout () : TransactionOutput[] {
-    return this._vout
+    return this._tx.vout.map((_, idx) => new TransactionOutput(this, idx))
   }
 
   add_vin (tx_input : TxInputTemplate) {
     const txin = create_tx_input(tx_input)
     this._tx.vin.push(txin)
-    this._update_vin()
   }
 
   add_vout (tx_output : TxOutput) {
     const txout = create_tx_output(tx_output)
     this._tx.vout.push(txout)
-    this._update_vout()
   }
 
   insert_vin (index : number, tx_input : TxInputTemplate) {
@@ -117,7 +99,6 @@ export class Transaction {
     } else {
       this._tx.vin.splice(index, 0, txin)
     }
-    this._update_vin()
   }
 
   insert_vout (index : number, tx_output : TxOutput) {
@@ -128,19 +109,16 @@ export class Transaction {
     } else {
       this._tx.vout.splice(index, 0, txout)
     }
-    this._update_vout()
   }
 
   remove_vin (index : number) {
     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 : number) {
     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 () {
@@ -153,23 +131,6 @@ export class Transaction {
     }
   }
 
-  _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/src/class/txin.ts

@@ -1,78 +1,86 @@
+import { Assert }             from '@vbyte/micro-lib'
+import { Transaction }        from './tx.js'
 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 {
-  assert_tx_input,
   encode_txin_sequence,
   get_txin_size,
 } from '@/lib/tx/index.js'
 
-import type { TxInput } from '@/types/index.js'
+import type { TxInput, TxOutput } from '@/types/index.js'
 
 export class TransactionInput {
 
-  private readonly _txin : TxInput
+  private readonly _tx    : Transaction
+  private readonly _index : number
 
-  constructor (txin : TxInput) {
-    assert_tx_input(txin)
-    this._txin = txin
+  constructor (
+    transaction : Transaction,
+    index       : number
+  ) {
+    this._tx    = transaction
+    this._index = index
   }
 
   get coinbase () : string | null {
-    return this._txin.coinbase
+    return this.data.coinbase
   }
 
   get data () : TxInput {
-    return this._txin
+    const txin = this._tx.data.vin.at(this.index)
+    Assert.exists(txin, 'txin not found')
+    return txin
   }
 
   get has_prevout () : boolean {
-    return this._txin.prevout !== null
+    return this.data.prevout !== null
+  }
+
+  get index () : number {
+    return this._index
   }
 
   get is_coinbase () : boolean {
-    return this._txin.coinbase !== null
+    return this.data.coinbase !== null
   }
 
-  get prevout () : TransactionOutput | null {
-    return this._txin.prevout
-      ? new TransactionOutput(this._txin.prevout)
-      : null
+  get prevout () : TxOutput | null {
+    return this.data.prevout
   }
 
   get script_sig () {
-    if (this._txin.script_sig === null) return 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 () : string {
-    return this._txin.txid
+    return this.data.txid
   }
 
   get vout () : number {
-    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
   }
 

package/src/class/txout.ts

@@ -1,7 +1,8 @@
+import { Assert }        from '@vbyte/micro-lib'
+import { Transaction }   from './tx.js'
 import { decode_script } from '@/lib/script/index.js'
 
 import {
-  assert_tx_output,
   get_txout_size,
   get_vout_type,
   get_vout_version
@@ -11,38 +12,48 @@ import type { TxOutput } from '@/types/index.js'
 
 export class TransactionOutput {
 
-  private readonly _txout : TxOutput
+  private readonly _tx    : Transaction
+  private readonly _index : number
 
-  constructor (txout : TxOutput) {
-    assert_tx_output(txout)
-    this._txout = txout
+  constructor (
+    transaction : Transaction,
+    index : number
+  ) {
+    this._tx    = transaction
+    this._index = index
   }
 
   get data () : TxOutput {
-    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 () : bigint {
-    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 }

package/src/class/witness.ts

@@ -1,11 +1,10 @@
-import { Buff, Bytes }   from '@vbyte/buff'
+import { Transaction }   from './tx.js'
 import { Assert }        from '@vbyte/micro-lib'
 import { decode_script } from '@/lib/script/index.js'
 
 import {
   parse_witness,
-  get_witness_size,
-  assert_witness,
+  get_witness_size
 } from '@/lib/witness/index.js'
 
 import type {
@@ -17,81 +16,58 @@ import type {
 
 export class TransactionWitness {
 
-  private readonly _elems : Buff[]
+  private readonly _tx    : Transaction
+  private readonly _index : number
 
-  private _data : WitnessData
-  private _size : WitnessSize
-
-  constructor (witness : Bytes[]) {
-    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 : Transaction,
+    index       : number
+  ) {
+    this._tx    = transaction
+    this._index = index
   }
 
   get annex () : string | null {
-    return this._data.annex
+    return this.data.annex
   }
 
   get cblock () : string | null {
-    return this._data.cblock
+    return this.data.cblock
   }
 
   get data () : WitnessData {
-    return this._data
+    return parse_witness(this.stack)
   }
 
   get params () : string[] {
-    return this._data.params
+    return this.data.params
   }
 
   get script () : ScriptField | null {
-    if (this._data.script === null) return 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 () : WitnessSize {
-    return this._size
+    return get_witness_size(this.stack)
   }
 
   get stack () : string[] {
-    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 () : WitnessType {
-    return this._data.type
+    return this.data.type
   }
 
   get version () : number | null {
-    return this._data.version
-  }
-
-  _update () {
-    this._data = parse_witness(this._elems)
-    this._size = get_witness_size(this._elems)
-  }
-
-  add (elem : Bytes) {
-    this._elems.push(Buff.bytes(elem))
-    this._update()
-  }
-
-  insert (index : number, elem : Bytes) {
-    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 : number) {
-    this._elems.splice(index, 1)
-    this._update()
+    return this.data.version
   }
 
   toJSON   () { return this.data }