@vbyte/btc-dev 1.0.0

package/src/class/txin.ts

@@ -0,0 +1,95 @@
+import { decode_script }      from '@/lib/script/index.js'
+import { TransactionOutput }  from './txout.js'
+import { TransactionWitness } from './witness.js'
+
+import {
+  encode_txin_sequence,
+  get_txin_size,
+  Sequence
+} from '@/lib/tx/index.js'
+
+import type {
+  TxInput,
+  TxInputField
+} from '@/types/index.js'
+
+export class TransactionInput {
+
+  private readonly _size    : number
+  private readonly _txin    : TxInput
+  private readonly _witness : TransactionWitness | null
+
+  constructor (txin : TxInput) {
+    this._size    = get_txin_size(txin)
+    this._txin    = txin
+    this._witness = txin.witness.length > 0
+      ? new TransactionWitness(txin.witness)
+      : null
+  }
+
+  get coinbase () : string | null {
+    return this._txin.coinbase
+  }
+
+  get data () : TxInputField {
+    return {
+      coinbase    : this.coinbase,
+      prevout     : this.prevout?.data ?? null,
+      script_sig  : this.script_sig,
+      sequence    : this.sequence,
+      size        : this.size,
+      txid        : this.txid,
+      vout        : this.vout,
+      witness     : this.witness?.data ?? null
+    }
+  }
+
+  get has_prevout () : boolean {
+    return this._txin.prevout !== null
+  }
+
+  get is_coinbase () : boolean {
+    return this._txin.coinbase !== null
+  }
+
+  get prevout () : TransactionOutput | null {
+    return this._txin.prevout
+      ? new TransactionOutput(this._txin.prevout)
+      : null
+  }
+
+  get script_sig () {
+    if (this._txin.script_sig === null) return null
+    return {
+      asm : decode_script(this._txin.script_sig),
+      hex : this._txin.script_sig
+    }
+  }
+
+  get sequence () {
+    return {
+      hex   : encode_txin_sequence(this._txin.sequence).hex,
+      data  : Sequence.decode(this._txin.sequence),
+      value : this._txin.sequence
+    }
+  }
+
+  get size () {
+    return this._size
+  }
+
+  get txid () : string {
+    return this._txin.txid
+  }
+
+  get vout () : number {
+    return this._txin.vout
+  }
+
+  get witness () {
+    return this._witness
+  }
+
+  toJSON   () { return this.data }
+  toString () { return JSON.stringify(this.data) }
+}

package/src/class/txout.ts

@@ -0,0 +1,57 @@
+import { decode_script } from '@/lib/script/index.js'
+
+import {
+  get_txout_size,
+  get_vout_info
+} from '@/lib/tx/index.js'
+
+import type { TxOutput, TxOutputField, TxOutputInfo } from '@/types/index.js'
+
+export class TransactionOutput {
+
+  private readonly _info  : TxOutputInfo
+  private readonly _size  : number
+  private readonly _txout : TxOutput
+
+  constructor (txout : TxOutput) {
+    this._info  = get_vout_info(txout)
+    this._size  = get_txout_size(txout)
+    this._txout = txout
+  }
+
+  get data () : TxOutputField {
+    return {
+      script_pk : this.script_pk,
+      size      : this.size,
+      type      : this.type,
+      value     : this.value,
+      version   : this.version
+    }
+  }
+
+  get script_pk () {
+    return {
+      hex : this._txout.script_pk,
+      asm : decode_script(this._txout.script_pk)
+    }
+  }
+
+  get size () {
+    return this._size
+  }
+
+  get type () {
+    return this._info.type
+  }
+
+  get value () : bigint {
+    return this._txout.value
+  }
+
+  get version () {
+    return this._info.version
+  }
+
+  toJSON   () { return this.data }
+  toString () { return JSON.stringify(this.data) }
+}

package/src/class/witness.ts

@@ -0,0 +1,85 @@
+import { Buff, Bytes }   from '@vbyte/buff'
+import { decode_script } from '@/lib/script/index.js'
+
+import {
+  parse_witness_data,
+  get_witness_size,
+} from '@/lib/tx/index.js'
+
+import type {
+  ScriptField,
+  WitnessField,
+  WitnessInfo,
+  WitnessSize,
+  WitnessType
+} from '@/types/index.js'
+
+export class TransactionWitness {
+
+  private readonly _data  : Buff[]
+  private readonly _meta  : WitnessInfo
+  private readonly _size  : WitnessSize
+
+  constructor (witness : Bytes[]) {
+    this._data  = witness.map(e => Buff.bytes(e))
+    this._meta  = parse_witness_data(witness)
+    this._size  = get_witness_size(witness)
+  }
+
+  get annex () : string | null {
+    return this._meta.annex
+  }
+
+  get cblock () : string | null {
+    return this._meta.cblock
+  }
+
+  get data () : WitnessField {
+    return {
+      annex   : this.annex,
+      cblock  : this.cblock,
+      params  : this.params,
+      script  : this.script,
+      size    : this.size,
+      stack   : this.stack,
+      type    : this.type,
+      version : this.version,
+      vsize   : this.vsize
+    }
+  }
+
+  get params () : string[] {
+    return this._meta.params
+  }
+
+  get script () : ScriptField | null {
+    if (this._meta.script === null) return null
+    return {
+      hex : this._meta.script,
+      asm : decode_script(this._meta.script)
+    }
+  }
+
+  get size () : number {
+    return this._size.size
+  }
+
+  get stack () : string[] {
+    return this._data.map(e => e.hex)
+  }
+
+  get type () : WitnessType {
+    return this._meta.type
+  }
+
+  get version () : number | null {
+    return this._meta.version
+  }
+
+  get vsize () : number {
+    return this._size.vsize
+  }
+
+  toJSON   () { return this.data }
+  toString () { return JSON.stringify(this.data) }
+}

package/src/const.ts

@@ -0,0 +1,43 @@
+export const COINBASE = {
+  TXID : '00'.repeat(32),
+  VOUT : 0xFFFFFFFF,
+}
+
+export const DEFAULT = {
+  LOCKTIME : 0,
+  SEQUENCE : 0xFFFFFFFF,
+  VERSION  : 2,
+}
+
+export const TAPLEAF_VERSIONS = [
+  0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce,
+  0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde,
+  0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee,
+  0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe,
+  0x66, 0x7e, 0x80, 0x84, 0x96, 0x98, 0xba, 0xbc,
+  0xbe
+]
+
+export const TAPLEAF_DEFAULT_VERSION = 0xc0
+
+export const LOCK_SCRIPT_REGEX : Record<string, RegExp> = {
+  'p2pkh'    : /^76a914[0-9a-f]{40}88ac$/i,
+  'p2sh'     : /^a914[0-9a-f]{40}87$/i,
+  'p2wpkh'   : /^0014[0-9a-f]{40}$/i,
+  'p2wsh'    : /^0020[0-9a-f]{64}$/i,
+  'p2tr'     : /^5120[0-9a-f]{64}$/i,
+  'opreturn' : /^6a[0-9a-f]{2,}$/i,
+}
+
+export const SCRIPT_INT_KEY = ''
+
+export const TX_SIZE = {
+  GLOBAL_BASE : 8,
+  GLOBAL_WIT  : 10,
+  TXIN_BASE   : 32 + 4 + 4,
+  TXOUT_BASE  : 8,
+}
+
+export const SIGHASH_DEFAULT = 0x01
+export const SIGHASH_SEGWIT  = [ 0x01, 0x02, 0x03, 0x81, 0x82, 0x83 ]
+export const SIGHASH_TAPROOT = [ 0x00, ...SIGHASH_SEGWIT ]

package/src/index.ts

@@ -0,0 +1,14 @@
+export * from './class/index.js'
+
+export * as Address from './lib/address/index.js'
+export * as Meta    from './lib/meta/index.js'
+export * as PSBT    from './lib/psbt/index.js'
+export * as Script  from './lib/script/index.js'
+export * as Sighash from './lib/sighash/index.js'
+export * as Taproot from './lib/taproot/index.js'
+export * as Tx      from './lib/tx/index.js'
+
+export * as CONST  from './const.js'
+export * as SCHEMA from './schema/index.js'
+
+export type * from './types/index.js'

package/src/lib/address/encode.ts

@@ -0,0 +1,183 @@
+import { Buff } from '@vbyte/buff'
+
+import { Assert, B58chk, Bech32, Bech32m } from '@vbyte/micro-lib'
+
+import type {
+  AddressFormat,
+  DecodedAddress,
+} from '@/types/address.js'
+
+const ENCODING_REGEX = {
+  base58  : /^[13mn2][a-km-zA-HJ-NP-Z1-9]{25,34}$/,
+  bech32  : /^(bc|tb|bcrt)1q[ac-hj-np-z02-9]{6,87}$/,
+  bech32m : /^(bc|tb|bcrt)1p[ac-hj-np-z02-9]{6,87}$/
+}
+
+const VERSION = {
+  bech32  : 0,
+  bech32m : 1
+}
+
+/**
+ * Decode an address.
+ * 
+ * @param address - The address to decode.
+ * @returns The decoded address.
+ */
+export function decode_address (address : string) : DecodedAddress {
+  // Get the address format.
+  const format = get_address_format(address)
+  // If the format is not found, throw an error.
+  if (format === null) throw new Error('unrecognized address format: ' + format)
+  // Decode the address based on the format.
+  if (format === 'base58')  return base58_decode(address)
+  if (format === 'bech32')  return bech32_decode(address)
+  if (format === 'bech32m') return bech32m_decode(address)
+  // If we didn't find a matching decoder, throw.
+  throw new Error('unable to find a matching address configuration')
+}
+
+/**
+ * Encode an address.
+ * 
+ * @param address - The address to encode.
+ * @returns The encoded address as a string, or null if the address is not
+ *          recognized.
+ */
+export function encode_address (
+  config : DecodedAddress
+) : string {
+  // Encode the address based on the format.
+  if (config.format === 'base58')  return base58_encode(config)
+  if (config.format === 'bech32')  return bech32_encode(config)
+  if (config.format === 'bech32m') return bech32m_encode(config)
+  // If the format is not recognized, throw an error.
+  throw new Error('unrecognized encoding format: ' + config.format)
+}
+
+/**
+ * Get the encoding type for a given address.
+ * 
+ * @param address - The address to get the encoding type for.
+ * @returns The encoding type, or null if the address is not recognized.
+ */
+function get_address_format (address : string) : AddressFormat | null {
+  // For each encoding type, check if the address matches the regex.
+  for (const [ format, regex ] of Object.entries(ENCODING_REGEX)) {
+    // If the address matches the regex, return the format.
+    if (regex.test(address)) return format as AddressFormat
+    // If the address does not match the regex, continue to the next encoding type.
+  }
+  // If no encoding type matches the address, return null.
+  return null
+}
+
+/**
+ * Encode data as a base58 string.
+ * 
+ * @param config - The encoder configuration.
+ * @returns The encoded base58 string.
+ */
+function base58_encode (config : DecodedAddress) : string {
+  // Assert the format is correct.
+  Assert.ok(config.format === 'base58', 'encoding mismatch')
+  // Assert the version is specified.
+  Assert.exists(config.version, 'must specify a version')
+  // Convert the data into bytes with a version prefix.
+  const bytes = Buff.join([ config.version, config.data ])
+  // Encode the data as a base58 string.
+  return B58chk.encode(bytes)
+}
+
+/**
+ * Decode data as a base58 string.
+ * 
+ * @param encoded - The base58 string to decode.
+ * @returns The decoded data.
+ */
+function base58_decode (encoded : string) : DecodedAddress {
+  // Decode the encoded data.
+  const bytes = B58chk.decode(encoded)
+  // Get the data from the decoded bytes.
+  const data  = bytes.slice(1)
+  // Get the version from the decoded bytes.
+  const version = bytes[0]
+  // Return the decoded address.
+  return { data, format: 'base58', version }
+}
+
+/**
+ * Encode data as a bech32 string.
+ * 
+ * @param config - The encoder configuration.
+ * @returns The encoded bech32 string.
+ */
+function bech32_encode (config : DecodedAddress) : string {
+  // Assert the format is correct.
+  Assert.ok(config.format === 'bech32', 'encoding mismatch')
+  // Assert the prefix is specified.
+  Assert.exists(config.prefix, 'prefix is required')
+  // Convert the data into bytes.
+  const bytes = Buff.bytes(config.data)
+  // Convert the bytes into words.
+  const words = Bech32.to_words(bytes)
+  // Encode the data as a bech32 string.
+  return Bech32.encode(config.prefix, [ VERSION.bech32, ...words ])
+}
+
+/**
+ * Decode data as a bech32 string.
+ * 
+ * @param encoded - The bech32 string to decode.
+ * @returns The decoded data.
+ */
+function bech32_decode (encoded : string) : DecodedAddress {
+  // Decode the encoded data.
+  const { prefix, words } = Bech32.decode(encoded)
+  // Get the version and rest of the words.
+  const [ version, ...rest ] = words
+  // Assert the version is correct.
+  Assert.ok(version === VERSION.bech32, 'bech32 version mismatch')
+  // Convert the rest of the words into bytes.
+  const data = Bech32.to_bytes(rest)
+  // Return the decoded address.
+  return { data, format: 'bech32', prefix, version }
+}
+
+/**
+ * Encode data as a bech32 string.
+ * 
+ * @param config - The encoder configuration.
+ * @returns The encoded bech32 string.
+ */
+function bech32m_encode (config : DecodedAddress) : string {
+  // Assert the format is correct.
+  Assert.ok(config.format === 'bech32m', 'encoding mismatch')
+  // Assert the prefix is specified.
+  Assert.exists(config.prefix, 'prefix is required')
+  // Convert the data into bytes.
+  const bytes   = Buff.bytes(config.data)
+  // Convert the bytes into words.
+  const words   = Bech32m.to_words(bytes)
+  // Encode the data as a bech32m string.
+  return Bech32m.encode(config.prefix, [ VERSION.bech32m, ...words ])
+}
+
+/**
+ * Decode data as a bech32 string.
+ * 
+ * @param encoded - The bech32 string to decode.
+ * @returns The decoded data.
+ */
+function bech32m_decode (encoded : string) : DecodedAddress {
+  // Decode the encoded data.
+  const { prefix, words }    = Bech32m.decode(encoded)
+  // Get the version and rest of the words.
+  const [ version, ...rest ] = words
+  // Assert the version is correct.
+  Assert.ok(version === VERSION.bech32m, 'bech32m version mismatch')
+  // Convert the rest of the words into bytes.
+  const data = Bech32m.to_bytes(rest)
+  // Return the decoded address.
+  return { data, format: 'bech32m', prefix, version }
+}

package/src/lib/address/index.ts

@@ -0,0 +1,24 @@
+import { P2PKH  as P2PKH_TOOL  } from './p2pkh.js'
+import { P2SH   as P2SH_TOOL   } from './p2sh.js'
+import { P2WPKH as P2WPKH_TOOL } from './p2wpkh.js'
+import { P2WSH  as P2WSH_TOOL  } from './p2wsh.js'
+import { P2TR   as P2TR_TOOL   } from './p2tr.js'
+
+import { parse_address } from './util.js'
+
+export { P2PKH }  from './p2pkh.js'
+export { P2SH }   from './p2sh.js'
+export { P2WPKH } from './p2wpkh.js'
+export { P2WSH }  from './p2wsh.js'
+export { P2TR }   from './p2tr.js'
+
+export { parse_address } from './util.js'
+
+export namespace AddressTool {
+  export const P2PKH   = P2PKH_TOOL
+  export const P2SH    = P2SH_TOOL
+  export const P2WPKH  = P2WPKH_TOOL
+  export const P2WSH   = P2WSH_TOOL
+  export const P2TR    = P2TR_TOOL
+  export const parse   = parse_address
+}

package/src/lib/address/p2pkh.ts

@@ -0,0 +1,65 @@
+import { Buff }           from '@vbyte/buff'
+import { Assert }         from '@vbyte/micro-lib'
+import { hash160 }        from '@vbyte/micro-lib/hash'
+import { encode_address } from './encode.js'
+
+import {
+  get_address_config,
+  parse_address
+} from './util.js'
+
+import type {
+  AddressData,
+  ChainNetwork
+} from '@/types/index.js'
+
+const ADDR_TYPE = 'p2pkh'
+
+export namespace P2PKH {
+  export const create = create_p2pkh_address
+  export const encode = encode_p2pkh_address
+  export const decode = decode_p2pkh_address
+}
+
+function create_p2pkh_address (
+  script  : string | Uint8Array,
+  network : ChainNetwork = 'main',
+) : string {
+  // Convert the script into bytes.
+  const bytes = Buff.bytes(script)
+  // Convert the bytes into a hash.
+  const hash = hash160(bytes)
+  // Encode the hash as an address.
+  return encode_p2pkh_address(hash, network)
+}
+
+function encode_p2pkh_address (
+  pk_hash : string | Uint8Array,
+  network : ChainNetwork = 'main',
+) : string {
+  // Convert the public key hash into bytes.
+  const bytes  = Buff.bytes(pk_hash)
+  // Get the address configuration.
+  const config = get_address_config(network, ADDR_TYPE)
+  // Assert the configuration exists.
+  Assert.exists(config,           `unrecognized address config: ${ADDR_TYPE} on ${network}` )
+  // Assert the payload size is correct.
+  Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}` )
+  // Encode the address.
+  return encode_address({
+    data    : bytes,
+    format  : 'base58',
+    version : config.version
+  })
+}
+
+function decode_p2pkh_address (
+  address : string
+) : AddressData {
+  // Parse the address.
+  const parsed = parse_address(address)
+  // Assert the address type is correct.
+  Assert.ok(parsed.type === 'p2pkh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE}`)
+  // Return the parsed address.
+  return parsed
+}

package/src/lib/address/p2sh.ts

@@ -0,0 +1,65 @@
+import { Buff }           from '@vbyte/buff'
+import { Assert }         from '@vbyte/micro-lib'
+import { hash160 }        from '@vbyte/micro-lib/hash'
+import { encode_address } from './encode.js'
+
+import {
+  get_address_config,
+  parse_address
+} from './util.js'
+
+import type {
+  ChainNetwork,
+  AddressData
+} from '@/types/index.js'
+
+const ADDR_TYPE = 'p2sh'
+
+export namespace P2SH {
+  export const create = create_p2sh_address
+  export const encode = encode_p2sh_address
+  export const decode = decode_p2sh_address
+}
+
+function create_p2sh_address (
+  script  : string | Uint8Array,
+  network : ChainNetwork = 'main',
+) : string {
+  // Convert the script into bytes.
+  const bytes = Buff.bytes(script)
+  // Convert the bytes into a hash.
+  const hash = hash160(bytes)
+  // Encode the address.
+  return encode_p2sh_address(hash, network)
+}
+
+function encode_p2sh_address (
+  script_hash : string | Uint8Array,
+  network     : ChainNetwork = 'main',
+) : string {
+  // Convert the script hash into bytes.
+  const bytes  = Buff.bytes(script_hash)
+  // Get the address configuration.
+  const config = get_address_config(network, ADDR_TYPE)
+  // Assert the configuration exists.
+  Assert.exists(config, `unrecognized address config: ${ADDR_TYPE} on ${network}` )
+  // Assert the payload size is correct.
+  Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}` )
+  // Encode the address.
+  return encode_address({
+    data    : bytes,
+    format  : 'base58',
+    version : config.version
+  })
+}
+
+function decode_p2sh_address (
+  address : string
+) : AddressData {
+  // Parse the address.
+  const parsed = parse_address(address)
+  // Assert the address type is correct.
+  Assert.ok(parsed.type === 'p2sh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE}`)
+  // Return the parsed address.
+  return parsed
+}

package/src/lib/address/p2tr.ts

@@ -0,0 +1,51 @@
+import { Buff }           from '@vbyte/buff'
+import { Assert }         from '@vbyte/micro-lib'
+import { encode_address } from './encode.js'
+
+import {
+  get_address_config,
+  parse_address
+} from './util.js'
+
+import type {
+  ChainNetwork,
+  AddressData
+} from '@/types/index.js'
+
+const ADDR_TYPE = 'p2tr'
+
+export namespace P2TR {
+  export const encode = encode_p2tr_address
+  export const decode = decode_p2tr_address
+}
+
+function encode_p2tr_address (
+  pubkey  : string | Uint8Array,
+  network : ChainNetwork = 'main'
+) : string {
+  // Convert the public key into bytes.
+  const bytes = Buff.bytes(pubkey)
+  // Get the address configuration.
+  const config = get_address_config(network, ADDR_TYPE)
+  // Assert the configuration exists.
+  Assert.exists(config, `unrecognized address config: ${ADDR_TYPE} on ${network}` )
+  // Assert the payload size is correct.
+  Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}` )
+  // Encode the address.
+  return encode_address({
+    data   : bytes,
+    format : 'bech32m',
+    prefix : config.prefix
+  })
+}
+
+function decode_p2tr_address (
+  address : string
+) : AddressData {
+  // Parse the address.
+  const parsed = parse_address(address)
+  // Assert the address type is correct.
+  Assert.ok(parsed.type === 'p2tr', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE}`)
+  // Return the parsed address.
+  return parsed
+}