@vbyte/btc-dev 1.0.9 → 1.0.11

package/package.json

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

package/src/class/signer.ts

@@ -1,5 +1,5 @@
 import { Buff, Bytes } from '@vbyte/buff'
-import { ECC }         from '@vbyte/micro-lib'
+import { Assert, ECC } from '@vbyte/micro-lib'
 
 import {
   sign_segwit_tx,
@@ -15,6 +15,8 @@ export class TxSigner {
   private readonly _seckey : string
 
   constructor (seckey : Bytes) {
+    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
   }
 

package/src/class/tx.ts

@@ -5,7 +5,6 @@ import { TransactionInput }  from './txin.js'
 import { TransactionOutput } from './txout.js'
 
 import {
-  decode_tx,
   get_txid,
   is_return_script,
   parse_tx,
@@ -21,8 +20,6 @@ import type {
   TxData,
   TxTemplate,
   TxOutput,
-  TxSize,
-  TxValue,
   TxInputTemplate
 } from '@/types/index.js'
 
@@ -30,23 +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 = (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 () : TxData {
@@ -54,7 +36,7 @@ export class Transaction {
   }
 
   get hash () : string {
-    return this._hash
+    return get_txhash(this._tx)
   }
 
   get locktime () {
@@ -70,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 {
@@ -92,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) {
@@ -119,7 +99,6 @@ export class Transaction {
     } else {
       this._tx.vin.splice(index, 0, txin)
     }
-    this._update_vin()
   }
 
   insert_vout (index : number, tx_output : TxOutput) {
@@ -130,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 () {
@@ -155,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,6 +1,7 @@
+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 {
@@ -8,69 +9,78 @@ import {
   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) {
-    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,3 +1,5 @@
+import { Assert }        from '@vbyte/micro-lib'
+import { Transaction }   from './tx.js'
 import { decode_script } from '@/lib/script/index.js'
 
 import {
@@ -10,37 +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) {
-    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,10 +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,
+  get_witness_size
 } from '@/lib/witness/index.js'
 
 import type {
@@ -16,80 +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[]) {
-    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 }

package/src/lib/tx/decode.ts

@@ -29,7 +29,7 @@ export function decode_tx (
   // Merge the options with the default config.
   const config = { ...DEFAULT_CONFIG, ...options }
   // Assert the txhex is a bytes object.
-  Assert.is_bytes(txbytes, 'txbytes must be hex or a unit array')
+  Assert.is_bytes(txbytes, 'transaction must be hex or a byte-array')
   // Setup a byte-stream.
   const stream = new Stream(txbytes)
   // Parse tx version.

package/src/lib/tx/size.ts

@@ -24,7 +24,7 @@ export function get_vsize (
 ) : number {
   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 (
@@ -35,7 +35,7 @@ export function get_txsize (
   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 }
 }
 

package/src/lib/witness/util.ts

@@ -1,4 +1,5 @@
 import { Buff, Bytes } from '@vbyte/buff'
+import { Assert }      from '@vbyte/micro-lib'
 
 import type { WitnessSize } from '@/types/index.js'
 
@@ -10,3 +11,8 @@ export function get_witness_size (witness : Bytes[]) : WitnessSize {
   const vsize = Math.ceil(WIT_LENGTH_BYTE + size / 4) 
   return { total: size, vsize }
 }
+
+export function assert_witness (witness : unknown) : asserts witness is Bytes[] {
+  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')
+}