@vbyte/btc-dev 1.0.10 → 1.0.12

package/src/lib/tx/decode.ts

@@ -1,45 +1,32 @@
-import { Bytes, Stream } from '@vbyte/buff'
-import { Assert }              from '@vbyte/micro-lib'
-import { parse_error }         from '@vbyte/micro-lib/util'
-import { COINBASE }            from '@/const.js'
+import { Stream }      from '@vbyte/buff'
+import { Assert }      from '@vbyte/micro-lib/assert'
+import { parse_error } from '@vbyte/micro-lib/util'
+import { COINBASE }    from '@/const.js'
 
 import {
-  TxData,
   TxInput,
   TxOutput,
   TxCoinbaseInput,
   TxVirtualInput,
-  TxSpendInput
+  TxDecodedData
 } from '@/types/index.js'
 
-interface TxEncoderConfig {
-  prevouts : TxOutput[]
-  segwit   : boolean
-}
-
-const DEFAULT_CONFIG : TxEncoderConfig = {
-  prevouts : [],
-  segwit   : true
-}
-
 export function decode_tx (
-  txbytes : Bytes,
-  options : Partial<TxEncoderConfig> = {}
-) : TxData {
-  // Merge the options with the default config.
-  const config = { ...DEFAULT_CONFIG, ...options }
-  // Assert the txhex is a bytes object.
-  Assert.is_bytes(txbytes, 'transaction must be hex or a byte-array')
+  txdata : string | Uint8Array,
+  use_segwit = true
+) : TxDecodedData {
+  // Assert the txdata is a bytes object.
+  Assert.is_bytes(txdata, 'txdata must be hex or bytes')
   // Setup a byte-stream.
-  const stream = new Stream(txbytes)
+  const stream = new Stream(txdata)
   // Parse tx version.
   const version = read_version(stream)
   // Check and enable any flags that are set.
-  const has_witness = (config.segwit)
+  const has_witness = (use_segwit)
     ? check_witness_flag(stream)
     : false
   // Parse our inputs and outputs.
-  const vin  = read_inputs(stream, config.prevouts)
+  const vin  = read_inputs(stream)
   const vout = read_outputs(stream)
   // If witness flag is set, parse witness data.
   if (has_witness) {
@@ -70,28 +57,26 @@ function check_witness_flag (stream : Stream) : boolean {
   return false
 }
 
-function read_inputs (stream : Stream, prevouts : TxOutput[]) : TxInput[] {
+function read_inputs (stream : Stream) : TxInput[] {
   const inputs = []
   const vinCount = stream.varint()
   for (let i = 0; i < vinCount; i++) {
-    const txinput = read_vin(stream, prevouts.at(i))
+    const txinput = read_vin(stream)
     inputs.push(txinput)
   }
   return inputs
 }
 
-function read_vin (stream : Stream, prevout : TxOutput | null = null) : TxInput {
+function read_vin (stream : Stream) : TxInput {
   const txid       = stream.read(32).reverse().hex
   const vout       = stream.read(4).reverse().num
-  const script_sig = read_script(stream, true)
+  const script_sig = read_payload(stream)
   const sequence   = stream.read(4).reverse().num
   const witness : string[] = []
   if (txid === COINBASE.TXID && vout === COINBASE.VOUT) {
     return { coinbase : script_sig, prevout: null, script_sig : null, sequence, txid, vout, witness } as TxCoinbaseInput
-  } else if (prevout !== null) {
-    return { coinbase : null, prevout, script_sig, sequence, txid, vout, witness } as TxSpendInput
   } else {
-    return { coinbase : null, prevout, script_sig, sequence, txid, vout, witness } as TxVirtualInput
+    return { coinbase : null, prevout: null, script_sig, sequence, txid, vout, witness } as TxVirtualInput
   }
 }
 
@@ -110,7 +95,7 @@ function read_outputs (stream : Stream) : TxOutput[] {
 
 function read_vout (stream : Stream) : TxOutput {
   const value     = stream.read(8).reverse().big
-  const script_pk = read_script(stream, true)
+  const script_pk = read_payload(stream)
   Assert.exists(script_pk, 'failed to decode script_pk')
   return { value, script_pk }
 }
@@ -119,7 +104,7 @@ function read_witness (stream : Stream) : string[] {
   const stack = []
   const count = stream.varint()
   for (let i = 0; i < count; i++) {
-    const element = read_script(stream, true)
+    const element = read_payload(stream)
     if (element === null) {
       throw new Error('failed to decode witness element: ' + i)
     }
@@ -128,16 +113,9 @@ function read_witness (stream : Stream) : string[] {
   return stack
 }
 
-export function read_script (
-  stream  : Stream,
-  varint ?: boolean
-) : string | null {
-  const size = (varint === true)
-    ? stream.varint('le')
-    : stream.size
-  return size > 0
-    ? stream.read(size).hex
-    : null
+export function read_payload (stream : Stream) : string | null {
+  const size = stream.varint('le')
+  return (size > 0) ? stream.read(size).hex : null
 }
 
 function read_locktime (stream : Stream) : number {

package/src/lib/tx/encode.ts

@@ -1,7 +1,7 @@
-import { Buff }          from '@vbyte/buff'
-import { Assert }        from '@vbyte/micro-lib'
-import { parse_tx }      from './parse.js'
-import { COINBASE }      from '@/const.js'
+import { Buff }           from '@vbyte/buff'
+import { Assert }         from '@vbyte/micro-lib'
+import { assert_tx_data } from './validate.js'
+import { COINBASE }       from '@/const.js'
 
 import {
   TxInput,
@@ -11,15 +11,16 @@ import {
 
 export function encode_tx (
   txdata : TxData,
-  segwit = true
+  use_segwit = true
 ) : Buff {
-  const tx = parse_tx(txdata)
+  // Assert the txdata is a valid tx data object.
+  assert_tx_data(txdata)
   // Unpack the transaction data.
-  const { version, vin, vout, locktime } = tx
+  const { version, vin, vout, locktime } = txdata
   // Create a buffer for the transaction.
   const buffer : Buff[] = [ encode_tx_version(version) ]
   // If the transaction is a segwit transaction,
-  if (segwit) {
+  if (use_segwit) {
     // Add the segwit marker to the buffer.
     buffer.push(Buff.hex('0001'))
   }
@@ -28,7 +29,7 @@ export function encode_tx (
   // Add the outputs to the buffer.
   buffer.push(encode_tx_outputs(vout))
   // If the transaction is a segwit transaction,
-  if (segwit) {
+  if (use_segwit) {
     // For each input in the transaction,
     for (const input of vin) {
       // Add the witness data to the buffer.

package/src/lib/tx/parse.ts

@@ -1,16 +1,69 @@
-import { decode_tx }          from './decode.js'
-import { create_tx     }      from './create.js'
-import { assert_tx_template } from './validate.js'
+import { Assert }                      from '@vbyte/micro-lib/assert'
+import { decode_tx }                   from './decode.js'
+import { assert_tx_template }          from './validate.js'
+import { create_tx, create_tx_output } from './create.js'
 
-import type { TxData } from '@/types/index.js'
+import type { TxData, TxOutputTemplate } from '@/types/index.js'
 
 export function parse_tx (
-  txdata : unknown
+  txdata    : unknown,
+  prevouts? : TxOutputTemplate[]
 ) : TxData {
-  if (typeof txdata === 'string') {
-    return decode_tx(txdata)
+  // Define the tx variable.
+  let tx : TxData
+  // If the txdata is a string or Uint8Array,
+  if (typeof txdata === 'string' || txdata instanceof Uint8Array) {
+    // Decode the tx.
+    tx = decode_tx(txdata)
   } else {
+    // Assert the txdata is a valid tx template.
     assert_tx_template(txdata)
-    return create_tx(txdata)
+    // Create the tx.
+    tx = create_tx(txdata)
+  }
+  // If the prevouts are provided,
+  if (prevouts) {
+    // Assert the prevouts are a non-empty array.
+    Assert.has_items(prevouts, 'prevouts must be a non-empty array')
+    // Iterate over the inputs.
+    for (const [ idx, vin ] of tx.vin.entries()) {
+      // Get the prevout.
+      const prevout = prevouts.at(idx)
+      // Assert the prevout exists.
+      Assert.exists(prevout, 'prevout not found for input index: ' + idx)
+      // Create the prevout.
+      vin.prevout = create_tx_output(prevout)
+    }
   }
+  // Return the tx.
+  return tx
+}
+
+export function serialize_tx (
+  txdata : unknown
+) : Record<string, unknown> {
+  const tx       = parse_tx(txdata)
+  const version  = tx.version
+  const locktime = tx.locktime
+
+  const vin  : Record<string, unknown>[] = []
+  const vout : Record<string, unknown>[] = []
+
+  for (const e of tx.vin) {
+    if (e.prevout !== null) {
+      vin.push({
+        script_pk : e.prevout.script_pk,
+        value     : Number(e.prevout.value)
+      })
+    }
+  }
+
+  for (const e of tx.vout) {
+    vout.push({
+      script_pk : e.script_pk,
+      value     : Number(e.value)
+    })
+  }
+
+  return { version, locktime, vin, vout }
 }

package/src/lib/tx/util.ts

@@ -1,12 +1,17 @@
-import { hash256 }             from '@vbyte/micro-lib/hash'
-import { LOCK_SCRIPT_REGEX }   from '@/const.js'
-import { encode_tx }           from './encode.js'
-import { parse_tx }            from './parse.js'
+import { Buff }               from '@vbyte/buff'
+import { Test }               from '@vbyte/micro-lib'
+import { Assert }             from '@vbyte/micro-lib/assert'
+import { hash256 }            from '@vbyte/micro-lib/hash'
+import { encode_tx }          from './encode.js'
+import { assert_tx_template } from './validate.js'
+
+import { DEFAULT, LOCK_SCRIPT_REGEX } from '@/const.js'
 
 import type {
   TxData,
   TxOutput,
   TxOutputInfo,
+  TxOutputTemplate,
   TxOutputType,
   TxValue,
   WitnessVersion
@@ -37,37 +42,69 @@ export function get_vout_version (
 ) : WitnessVersion {
   const wit_ver = script.slice(0, 4)
   switch (wit_ver) {
-    case '0014':
-      return 0
-    case '5120':
-      return 1
-    default:
-      return null
+    case '0014' : return 0
+    case '5120' : return 1
+    default     : return null
   }
 }
 
 export function get_txid (
-  txdata : string | TxData
+  txdata : TxData
 ) : string {
-  const json = parse_tx(txdata)
-  const data = encode_tx(json, false)
+  assert_tx_template(txdata)
+  const data = encode_tx(txdata, false)
   return hash256(data).reverse().hex
 }
 
 export function get_txhash (
-  txdata : string | TxData
+  txdata : TxData
 ) : string {
-  const json = parse_tx(txdata)
-  const data = encode_tx(json, true)
+  assert_tx_template(txdata)
+  const data = encode_tx(txdata, true)
   return hash256(data).reverse().hex
 }
 
 export function get_tx_value (
-  txdata : string | TxData
+  txdata : TxData
 ) : TxValue {
-  const tx   = parse_tx(txdata)
-  const vin  = tx.vin.reduce((acc, txin) => acc + (txin.prevout?.value ?? 0n), 0n)
-  const vout = tx.vout.reduce((acc, txout) => acc + txout.value, 0n)
+  const vin  = txdata.vin.reduce((acc, txin) => acc + (txin.prevout?.value ?? 0n), 0n)
+  const vout = txdata.vout.reduce((acc, txout) => acc + txout.value, 0n)
   const fees = (vin > vout) ? (vin - vout) : 0n
   return { fees, vin, vout }
 }
+
+export function get_prevouts (txdata : TxData) : TxOutput[] {
+  // Assert the structure of the transaction data is valid.
+  assert_tx_template(txdata)
+  // Collect the prevouts from the transaction.
+  const prevouts = txdata.vin.map(e => e.prevout)
+  // Assert that all the prevouts are defined.
+  Assert.ok(prevouts.every(e => e !== null), 'prevouts missing from tx')
+  // Return the array of prevouts.
+  return prevouts
+}
+
+export function normalize_sequence (sequence? : number | string | null) : number {
+  // If sequence is not defined, return a default sequence value.
+  if (!Test.exists(sequence)) return DEFAULT.SEQUENCE
+  // If sequence is a hex string, decode it and return the number value.
+  if (Test.is_hex(sequence)) return Buff.hex(sequence as string, 4).reverse().num
+  // If sequence is a valid unsigned integer, return the value.
+  if (Test.is_uint(sequence)) return sequence
+  // Else, throw an error.
+  throw new Error('invalid sequence value: ' + String(sequence))
+}
+
+export function normalize_value (value : number | bigint) : bigint {
+  // If value is a unsigned integer, return it as a bigint.
+  if (Test.is_uint(value)) return BigInt(value)
+  // If value is a bigint, return it as-is.
+  if (typeof value === 'bigint') return value
+  // Else, throw an error.
+  throw new TypeError('invalid output value: ' + String(value))
+}
+
+export function normalize_prevout (prevout : TxOutputTemplate) : TxOutput {
+  // Return the output with a normalized value.
+  return { script_pk: prevout.script_pk, value: normalize_value(prevout.value) }
+}

package/src/lib/tx/validate.ts

@@ -7,6 +7,8 @@ import {
   TxInputTemplate,
   TxOutput,
   TxTemplate,
+  TxOutputTemplate,
+  TxSpendData,
 } from '@/types/index.js'
 
 export function assert_tx_template (txdata : unknown) : asserts txdata is TxTemplate {
@@ -23,6 +25,13 @@ export function assert_tx_data (txdata : unknown) : asserts txdata is TxData {
   Schema.tx.tx_data.parse(txdata)
 }
 
+export function assert_tx_spend_data (txdata : unknown) : asserts txdata is TxSpendData {
+  // Assert the txdata is a valid tx data object.
+  assert_tx_data(txdata)
+  // Assert the txdata has prevouts.
+  assert_has_prevouts(txdata.vin)
+}
+
 export function assert_tx_input (tx_input : unknown) : asserts tx_input is TxInput {
   Schema.tx.tx_input.parse(tx_input)
 }
@@ -31,6 +40,10 @@ export function assert_tx_output (tx_output : unknown) : asserts tx_output is Tx
   Schema.tx.tx_output.parse(tx_output)
 }
 
-export function assert_vin_template (vin_template : unknown) : asserts vin_template is TxInputTemplate {
-  Schema.tx.vin_template.parse(vin_template)
+export function assert_vin_template (vin : unknown) : asserts vin is TxInputTemplate {
+  Schema.tx.vin_template.parse(vin)
+}
+
+export function assert_vout_template (vout : unknown) : asserts vout is TxOutputTemplate {
+  Schema.tx.vout_template.parse(vout)
 }

package/src/schema/tx.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod'
 
-import { big, hex, hex32, uint } from '@vbyte/micro-lib/schema'
+import { hex, hex32, uint } from '@vbyte/micro-lib/schema'
 
-export const sats = big.max(2_100_000_000_000_000n)
+const sats  = z.bigint().positive().max(2_100_000_000_000_000n)
 
 export const tx_output = z.object({
   value     : sats,
@@ -26,17 +26,21 @@ export const tx_data = z.object({
   locktime : uint,
 })
 
+export const vout_template = tx_output.extend({
+  value : z.union([ uint, sats ])
+})
+
 export const vin_template = tx_input.extend({
   coinbase   : hex.nullable().optional(),
-  prevout    : tx_output.nullable().optional(),
+  prevout    : vout_template.nullable().optional(),
   script_sig : hex.nullable().optional(),
-  sequence   : uint.optional(),
+  sequence   : z.union([ hex, uint ]).optional(),
   witness    : z.array(hex).optional(),
 })
 
 export const tx_template = z.object({
-  version  : uint.optional(),
+  version  : uint.default(1),
   vin      : z.array(vin_template).default([]),
-  vout     : z.array(tx_output).default([]),
+  vout     : z.array(vout_template).default([]),
   locktime : uint.optional(),
 })

package/src/types/txdata.ts

@@ -5,7 +5,7 @@ export interface TxOutpoint {
   vout : number
 }
 
-export interface TxInputTemplate extends TxOutpoint {
+export interface TxInputConfig extends TxOutpoint {
   coinbase?   : string   | null
   prevout?    : TxOutput | null
   script_sig? : string   | null
@@ -13,6 +13,14 @@ export interface TxInputTemplate extends TxOutpoint {
   witness?    : string[]
 }
 
+export interface TxInputTemplate extends TxOutpoint {
+  coinbase   : string   | null
+  prevout    : TxOutput | null
+  script_sig : string   | null
+  sequence   : number
+  witness    : string[]
+}
+
 export interface TxCoinbaseInput extends TxOutpoint {
   coinbase   : string
   prevout    : null
@@ -33,16 +41,21 @@ export interface TxSpendInput extends TxVirtualInput {
   prevout : TxOutput
 }
 
+export interface TxOutputTemplate {
+  script_pk : string
+  value     : number | bigint
+}
+
 export interface TxOutput {
   script_pk : string
   value     : bigint
 }
 
 export interface TxTemplate {
-  locktime? : number
-  vin?      : TxInputTemplate[]
-  vout?     : TxOutput[]
-  version?  : number
+  locktime : number
+  vin      : TxInputTemplate[]
+  vout     : TxOutputTemplate[]
+  version  : number
 }
 
 export interface TxData {
@@ -52,6 +65,20 @@ export interface TxData {
   version  : number
 }
 
+export interface TxDecodedData {
+  locktime : number
+  vin      : (TxCoinbaseInput | TxVirtualInput)[]
+  vout     : TxOutput[]
+  version  : number
+}
+
+export interface TxSpendData {
+  locktime : number
+  vin      : TxSpendInput[]
+  vout     : TxOutput[]
+  version  : number
+}
+
 export interface TxSize {
   base   : number
   total  : number

package/dist/class/index.d.ts

@@ -1,5 +0,0 @@
-export * from './signer.js';
-export * from './tx.js';
-export * from './txin.js';
-export * from './txout.js';
-export * from './witness.js';

package/dist/class/index.js

@@ -1,5 +0,0 @@
-export * from './signer.js';
-export * from './tx.js';
-export * from './txin.js';
-export * from './txout.js';
-export * from './witness.js';

package/dist/class/signer.d.ts

@@ -1,18 +0,0 @@
-import { Buff, Bytes } from '@vbyte/buff';
-import type { SigHashOptions, TxData } from '../types/index.js';
-export declare class TxSigner {
-    private readonly _seckey;
-    constructor(seckey: Bytes);
-    get pubkey(): {
-        segwit: Buff;
-        taproot: Buff;
-    };
-    get sign_msg(): {
-        ecdsa: (msg: Bytes) => Buff;
-        bip340: (msg: Bytes) => Buff;
-    };
-    get sign_tx(): {
-        segwit: (tx: TxData, options: SigHashOptions) => string;
-        taproot: (tx: TxData, options: SigHashOptions) => string;
-    };
-}

package/dist/class/signer.js

@@ -1,34 +0,0 @@
-import { Buff } from '@vbyte/buff';
-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() {
-        return {
-            segwit: ECC.get_pubkey(this._seckey, 'ecdsa'),
-            taproot: ECC.get_pubkey(this._seckey, 'bip340')
-        };
-    }
-    get sign_msg() {
-        return {
-            ecdsa: (msg) => {
-                const bytes = Buff.bytes(msg);
-                return ECC.sign_ecdsa(this._seckey, bytes);
-            },
-            bip340: (msg) => {
-                const bytes = Buff.bytes(msg);
-                return ECC.sign_bip340(this._seckey, bytes);
-            }
-        };
-    }
-    get sign_tx() {
-        return {
-            segwit: (tx, options) => sign_segwit_tx(this._seckey, tx, options),
-            taproot: (tx, options) => sign_taproot_tx(this._seckey, tx, options)
-        };
-    }
-}

package/dist/class/tx.d.ts

@@ -1,51 +0,0 @@
-import { TransactionInput } from './txin.js';
-import { TransactionOutput } from './txout.js';
-import type { TxData, TxTemplate, TxOutput, TxSize, TxValue, 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;
-    get locktime(): {
-        hex: string;
-        data: import("../types/index.js").LocktimeData | null;
-        value: number;
-    };
-    get return(): TxOutput | null;
-    get size(): TxSize & {
-        segwit: number;
-    };
-    get spends(): TransactionOutput[];
-    get txid(): string;
-    get value(): TxValue;
-    get version(): number;
-    get vin(): TransactionInput[];
-    get vout(): TransactionOutput[];
-    add_vin(tx_input: TxInputTemplate): void;
-    add_vout(tx_output: TxOutput): void;
-    insert_vin(index: number, tx_input: TxInputTemplate): void;
-    insert_vout(index: number, tx_output: TxOutput): void;
-    remove_vin(index: number): void;
-    remove_vout(index: number): void;
-    _get_size(): {
-        segwit: number;
-        vin: number;
-        vout: number;
-        witness: number;
-        base: number;
-        total: number;
-        vsize: number;
-        weight: number;
-    };
-    _update_tx(): void;
-    _update_vin(): void;
-    _update_vout(): void;
-    toJSON(): TxData;
-    toString(): string;
-}