@vbyte/btc-dev 1.1.8 → 2.0.0

package/src/lib/tx/encode.ts

@@ -1,155 +0,0 @@
-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,
-  TxOutput,
-  TxData
-} from '@/types/index.js'
-
-export function encode_tx (
-  txdata : TxData,
-  use_segwit = true
-) : Buff {
-  // Assert the txdata is a valid tx data object.
-  assert_tx_data(txdata)
-  // Unpack the transaction data.
-  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 (use_segwit) {
-    // Add the segwit marker to the buffer.
-    buffer.push(Buff.hex('0001'))
-  }
-  // Add the inputs to the buffer.
-  buffer.push(encode_tx_inputs(vin))
-  // Add the outputs to the buffer.
-  buffer.push(encode_tx_outputs(vout))
-  // If the transaction is a segwit transaction,
-  if (use_segwit) {
-    // For each input in the transaction,
-    for (const input of vin) {
-      // Add the witness data to the buffer.
-      buffer.push(encode_vin_witness(input.witness))
-    }
-  }
-  // Add the locktime to the buffer.
-  buffer.push(encode_tx_locktime(locktime))
-  // Return the buffer as a single payload. 
-  return Buff.join(buffer)
-}
-
-export function encode_tx_version (num : number) : Buff {
-  // Encode the transaction version as a 4-byte little-endian number.
-  return Buff.num(num, 4).reverse()
-}
-
-export function encode_txin_txid (txid : string) : Buff {
-  // Encode the transaction ID as a 32-byte little-endian number.
-  return Buff.hex(txid, 32).reverse()
-}
-
-export function encode_txin_vout (vout : number) : Buff {
-  // Encode the output index as a 4-byte little-endian number.
-  return Buff.num(vout, 4).reverse()
-}
-
-export function encode_txin_sequence (sequence : number) : Buff {
-  // Encode the sequence number as a 4-byte little-endian number.
-  return Buff.num(sequence, 4).reverse()
-}
-
-export function encode_tx_inputs (vin : TxInput[]) : Buff {
-  // Create a buffer for the inputs, starting with the array length.
-  const raw : Buff[] = [ Buff.varint(vin.length, 'le') ]
-  // For each input in the array,
-  for (const input of vin) {
-    // Encode the input, and add it to the buffer.
-    raw.push(encode_vin(input))
-  }
-  // Return the buffer as a single payload.
-  return Buff.join(raw)
-}
-
-export function encode_vin (txin : TxInput) : Buff {
-  // If the input is a coinbase,
-  if (txin.coinbase !== null) {
-    // Encode and return the coinbase as a single payload.
-    return Buff.join([
-      encode_txin_txid(COINBASE.TXID),
-      encode_txin_vout(COINBASE.VOUT),
-      encode_script_data(txin.coinbase),
-      encode_txin_sequence(txin.sequence)
-    ])
-  } else {
-    // Encode and return the input as a single payload.
-    return Buff.join([
-      encode_txin_txid(txin.txid),
-      encode_txin_vout(txin.vout),
-      encode_script_data(txin.script_sig),
-      encode_txin_sequence(txin.sequence)
-    ])
-    }
-}
-
-export function encode_vout_value (value : bigint) : Buff {
-  // Encode the value as an 8-byte little-endian number.
-  return Buff.big(value, 8).reverse()
-}
-
-export function encode_tx_outputs (vout : TxOutput[]) : Buff {
-  // Create a buffer for the outputs, starting with the array length.
-  const buffer : Buff[] = [ Buff.varint(vout.length, 'le') ]
-  // For each output in the array,
-  for (const output of vout) {
-    // Encode the output, and add it to the buffer.
-    buffer.push(encode_tx_vout(output))
-  }
-  // Return the buffer as a single payload.
-  return Buff.join(buffer)
-}
-
-export function encode_tx_vout (txout : TxOutput) : Buff {
-  // Get the value and script pubkey from the output.
-  const { value, script_pk } = txout
-  // Return the data encoded as a single payload.
-  return Buff.join([
-    encode_vout_value(value),
-    encode_script_data(script_pk)
-  ])
-}
-
-export function encode_vin_witness (data : string[]) : Buff {
-  // Create a buffer for the witness data, starting with the array length.
-  const buffer : Buff[] = [ Buff.varint(data.length) ]
-  // For each parameter in the witness array,
-  for (const param of data) {
-    // Encode the parameter, and add it to the buffer.
-    buffer.push(encode_script_data(param))
-  }
-  // Return the buffer as a single payload.
-  return Buff.join(buffer)
-}
-
-export function encode_tx_locktime (locktime : number) : Buff {
-  // Encode the locktime as a 4-byte little-endian number.
-  return Buff.num(locktime, 4).reverse()
-}
-
-export function encode_script_data (
-  script : string | null
-) : Buff {
-  // If the script is not null,
-  if (script !== null) {
-    // Assert that the script is a hex string.
-    Assert.is_hex(script)
-    // Encode the script, and add it to the buffer.
-    return Buff.hex(script).prefix_varint('le')
-  } else {
-    // Return a single byte of zero.
-    return Buff.hex('00')
-  }
-}

package/src/lib/tx/index.ts

@@ -1,7 +0,0 @@
-export * from './create.js'
-export * from './decode.js'
-export * from './encode.js'
-export * from './util.js'
-export * from './parse.js'
-export * from './size.js'
-export * from './validate.js'

package/src/lib/tx/parse.ts

@@ -1,69 +0,0 @@
-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, TxOutputTemplate } from '@/types/index.js'
-
-export function parse_tx (
-  txdata    : unknown,
-  prevouts? : TxOutputTemplate[]
-) : 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)
-    // 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/size.ts

@@ -1,68 +0,0 @@
-import { Buff, Bytes }   from '@vbyte/buff'
-import { parse_tx }      from './parse.js'
-
-import {
-  encode_tx,
-  encode_tx_inputs,
-  encode_tx_outputs,
-  encode_tx_vout,
-  encode_vin,
-  encode_vin_witness
-} from './encode.js'
-
-import type {
-  TxData,
-  TxInput,
-  TxOutput,
-  TxSize
-} from '@/types/index.js'
-
-const WIT_FLAG_BYTES = 2
-
-export function get_vsize (
-  bytes : Bytes
-) : number {
-  const weight = Buff.bytes(bytes).length
-  const remain = (weight % 4 > 0) ? 1 : 0
-  return Math.ceil(weight / 4) + remain
-}
-
-export function get_txsize (
-  txdata : string | TxData
-) : TxSize {
-  const json   = parse_tx(txdata)
-  const base   = encode_tx(json, false).length
-  const total  = encode_tx(json, true).length
-  const weight = base * 3 + total
-  const remain = (weight % 4 > 0) ? 1 : 0
-  const vsize  = Math.ceil(weight / 4) + remain
-  return { base, total, vsize, weight }
-}
-
-export function get_vin_size (vin : TxInput[]) : number {
-  const bytes = encode_tx_inputs(vin)
-  return bytes.length
-}
-
-export function get_vout_size (vout : TxOutput[]) : number {
-  const bytes = encode_tx_outputs(vout)
-  return bytes.length
-}
-
-export function get_segwit_size (txinputs : TxInput[]) : number {
-  const segwit_data = txinputs
-    .filter(e => e.witness.length > 0)
-    .map(e => e.witness)
-  return WIT_FLAG_BYTES + segwit_data
-    .reduce((acc, e) => acc + encode_vin_witness(e).length, 0)
-}
-
-export function get_txin_size (txinput : TxInput) : number {
-  const bytes = encode_vin(txinput)
-  return bytes.length
-}
-
-export function get_txout_size (txoutput : TxOutput) : number {
-  const bytes = encode_tx_vout(txoutput)
-  return bytes.length
-}

package/src/lib/tx/util.ts

@@ -1,111 +0,0 @@
-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 { decode_tx }          from './decode.js'
-import { encode_tx }          from './encode.js'
-import { parse_tx }           from './parse.js'
-import { assert_tx_template } from './validate.js'
-
-import { DEFAULT } from '@/const.js'
-
-import type {
-  TxData,
-  TxOutput,
-  TxOutputTemplate,
-  TxValue
-} from '@/types/index.js'
-
-export function transcode_tx (
-  txdata : string | Uint8Array,
-  use_segwit = true
-) : Buff {
-  // Decode the transaction data.
-  const decoded = decode_tx(txdata)
-  // Re-encode and return the encoded transaction data.
-  return encode_tx(decoded, use_segwit)
-}
-
-export function get_txid (txdata : string | Uint8Array | TxData) : string {
-  let buffer : Uint8Array
-
-  if (txdata instanceof Uint8Array) {
-    // Set the buffer to the transaction data.
-    buffer = transcode_tx(txdata, false)
-  } else if (typeof txdata === 'object') {
-    // Assert the structure of the transaction data is valid.
-    assert_tx_template(txdata)
-    // Encode the transaction data.
-    buffer = encode_tx(txdata, false)
-  } else if (typeof txdata === 'string') {
-    // Assert the transaction data is a hex string.
-    Assert.is_hex(txdata)
-    // Convert the hex string to a Uint8Array.
-    buffer = transcode_tx(txdata, false)
-  } else {
-    throw new TypeError('invalid txdata type: ' + typeof txdata)
-  }
-  // Return the txid of the transaction data.
-  return hash256(buffer).reverse().hex
-}
-
-export function get_txhash (txdata : string | Uint8Array | TxData) : string {
-  // If the transaction data is an object,
-  if (typeof txdata === 'object') {
-    // Assert the structure of the transaction data is valid.
-    assert_tx_template(txdata)
-    // Encode the transaction data.
-    txdata = encode_tx(txdata, true)
-  }
-  // Return the txhash of the transaction data.
-  return hash256(txdata).reverse().hex
-}
-
-export function get_tx_value (txdata : string | Uint8Array | TxData) : TxValue {
-  // Parse the transaction data.
-  const tx = parse_tx(txdata)
-  // Assert the structure of the transaction data is valid.
-  assert_tx_template(tx)
-  // Calculate the value of the transaction.
-  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 fees = (vin > vout) ? (vin - vout) : 0n
-  // Return the value of the transaction.
-  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

@@ -1,49 +0,0 @@
-import * as Schema from '@/schema/index.js'
-
-import {
-  TxSpendInput,
-  TxData,
-  TxInput,
-  TxInputTemplate,
-  TxOutput,
-  TxTemplate,
-  TxOutputTemplate,
-  TxSpendData,
-} from '@/types/index.js'
-
-export function assert_tx_template (txdata : unknown) : asserts txdata is TxTemplate {
-  Schema.tx.tx_template.parse(txdata)
-}
-
-export function assert_has_prevouts (vin : TxInput[]) : asserts vin is TxSpendInput[] {
-  if (vin.some(txin => txin.prevout === null)) {
-    throw new Error('transaction missing prevouts')
-  }
-}
-
-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)
-}
-
-export function assert_tx_output (tx_output : unknown) : asserts tx_output is TxOutput {
-  Schema.tx.tx_output.parse(tx_output)
-}
-
-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/lib/witness/index.ts

@@ -1,2 +0,0 @@
-export * from './parse.js'
-export * from './util.js'

package/src/lib/witness/parse.ts

@@ -1,127 +0,0 @@
-import { Buff, Bytes }      from '@vbyte/buff'
-import { is_valid_script }  from '@/lib/script/decode.js'
-import { TAPLEAF_VERSIONS } from '@/const.js'
-
-import type {
-  WitnessData,
-  SpendScriptType,
-  WitnessVersion
-} from '@/types/index.js'
-
-export function parse_witness (
-  witness : Bytes[]
-) : WitnessData {
-  // Parse the witness data.
-  const elems   = witness.map(e => Buff.bytes(e))
-  const stack   = witness.map(e => Buff.bytes(e).hex)
-  const annex   = parse_annex_data(elems)
-  if (annex !== null) elems.pop()
-  const cblock  = parse_cblock_data(elems)
-  if (cblock !== null) elems.pop()
-  const type    = parse_witness_type(elems, cblock)
-  const version = parse_witness_version(type)
-  const script  = parse_witness_script(elems, type)
-  if (script !== null) elems.pop()
-  const params  = elems.map(e => e.hex)
-  return { annex, cblock, params, script, stack, type, version }
-}
-
-function parse_annex_data (
-  data : Uint8Array[]
-) : string | null {
-  // Get the last element of the array.
-  let elem = data.at(-1)
-  // Check if the element fits the annex format.
-  if (
-    data.length > 1            &&
-    elem instanceof Uint8Array &&
-    elem[0] === 0x50
-  ) {
-    // Return the element.
-    return new Buff(elem).hex
-  } else {
-    // Return null.
-    return null
-  }
-}
-
-function parse_cblock_data (
-  data : Uint8Array[]
-) : string | null {
-  let elem = data.at(-1)
-  if (
-    data.length > 1            &&
-    elem instanceof Uint8Array &&
-    elem.length > 32           &&
-    TAPLEAF_VERSIONS.includes(elem[0] & 0xfe)
-  ) {
-    // Return the element.
-    return new Buff(elem).hex
-  } else {
-    // Return null.
-    return null
-  }
-}
-
-function parse_witness_script (
-  elems : Uint8Array[],
-  type  : SpendScriptType | null
-) {
-  let script : Uint8Array | undefined
-  switch (type) {
-    case 'p2ts':
-      script = elems.at(-1)
-    case 'p2wsh':
-      script = elems.at(-1)
-  }
-  return (script !== undefined) ? new Buff(script).hex : null
-}
-
-function parse_witness_type (
-  elems  : Uint8Array[],
-  cblock : string | null
-) : SpendScriptType | null{
-  // Get the important elements of the witness.
-  let param_0 = elems.at(0),
-      param_1 = elems.at(1),
-      param_x = elems.at(-1)
-  // If the cblock is present and the last element exists:
-  if (cblock !== null && param_x !== undefined) {
-    return 'p2ts'
-  // If the witness elements match the profile of a p2w-pkh:
-  } else if (
-    elems.length === 2    &&
-    param_0 !== undefined &&
-    param_1 !== undefined &&
-    param_0.length >=  64 &&
-    param_1.length === 33
-  ) {
-    return 'p2wpkh'
-  // If the witness elements match the profile of a p2tr-pk:
-  } else if (
-    elems.length === 1    &&
-    param_0 !== undefined &&
-    param_0.length === 64
-  ) {
-    return 'p2tr'
-  // If there is at least two witness elements:
-  } else if (
-    elems.length > 1      && 
-    param_x !== undefined &&
-    is_valid_script(param_x)
-  ) {
-    return 'p2wsh'
-  // If the witness elements don't match any known profile:
-  } else {
-    return null
-  }
-}
-
-function parse_witness_version (
-  type : SpendScriptType | null
-) : WitnessVersion | null {
-  if (type === null) return null
-  if (type.startsWith('p2w')) return 0
-  if (type.startsWith('p2t')) return 1
-  return null
-}

package/src/lib/witness/util.ts

@@ -1,18 +0,0 @@
-import { Buff, Bytes } from '@vbyte/buff'
-import { Assert }      from '@vbyte/micro-lib'
-
-import type { WitnessSize } from '@/types/index.js'
-
-const WIT_LENGTH_BYTE = 1
-
-export function get_witness_size (witness : Bytes[]) : WitnessSize {
-  const stack = witness.map(e => Buff.bytes(e))
-  const size  = stack.reduce((prev, next) => prev + next.length, 0)
-  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')
-}

package/src/schema/base.ts

@@ -1,57 +0,0 @@
-import { z } from 'zod'
-
-type Literal = z.infer<typeof literal>
-type Json    = Literal | { [key : string] : Json } | Json[]
-
-export const big     = z.bigint()
-export const bool    = z.boolean()
-export const date    = z.date()
-export const num     = z.number().min(Number.MIN_SAFE_INTEGER).max(Number.MAX_SAFE_INTEGER)
-export const int     = num.int()
-export const u8a     = z.instanceof(Uint8Array)
-export const str     = z.string()
-export const stamp   = int.min(500_000_000)
-export const any     = z.any()
-export const zod     = z
-export const char  = int.min(0).max(0xFF)
-export const short = int.min(0).max(0xFFFF)
-export const uint  = int.min(0).max(0xFFFFFFFF)
-
-export const float  = z.number().refine((e) => String(e).includes('.'))
-
-export const float2 = float.refine((e) => {
-  const parts = String(e).split('.').at(1)
-  return parts !== undefined && parts.length <= 2
-})
-
-export const hex = z.string()
-  .regex(/^[0-9a-fA-F]*$/)
-  .refine(e => e.length % 2 === 0)
-
-export const literal = z.union([
-  z.string(), z.number(), z.boolean(), z.null()
-])
-
-export const json : z.ZodType<Json> = z.lazy(() =>
-  z.union([ literal, z.array(json), z.record(str, json) ])
-)
-
-export const u8a20    = u8a.refine((e) => e.length === 20)
-export const u8a32    = u8a.refine((e) => e.length === 32)
-export const u8a33    = u8a.refine((e) => e.length === 33)
-export const u8a64    = u8a.refine((e) => e.length === 64)
-
-export const hex20    = hex.refine((e) => e.length === 40)
-export const hex32    = hex.refine((e) => e.length === 64)
-export const hex33    = hex.refine((e) => e.length === 66)
-export const hex64    = hex.refine((e) => e.length === 128)
-
-export const bytes  = z.union([ hex, u8a ])
-export const byte32 = z.union([ hex32, u8a32 ])
-export const byte33 = z.union([ hex33, u8a33 ])
-export const byte64 = z.union([ hex64, u8a64 ])
-
-export const base58    = z.string().regex(/^[1-9A-HJ-NP-Za-km-z]+$/)
-export const base64    = z.string().regex(/^[a-zA-Z0-9+/]+={0,2}$/)
-export const base64url = z.string().regex(/^[a-zA-Z0-9\-_]+={0,2}$/)
-export const bech32    = z.string().regex(/^[a-z]+1[023456789acdefghjklmnpqrstuvwxyz]+$/)

package/src/schema/index.ts

@@ -1,2 +0,0 @@
-export * as taproot from './taproot.js'
-export * as tx      from './tx.js'

package/src/schema/taproot.ts

@@ -1,12 +0,0 @@
-import { z } from 'zod'
-
-import { byte32, uint } from './base.js'
-
-export const taptree = z.union([ z.array(byte32), byte32 ])
-
-export const config = z.object({
-  pubkey  : byte32,
-  leaves  : taptree.array().optional(),
-  target  : byte32.optional(),
-  version : uint.optional(),
-})