@vbyte/btc-dev 1.1.8 → 2.0.0

package/src/lib/signer/sign.ts

@@ -1,39 +0,0 @@
-import { Buff }            from '@vbyte/buff'
-import { ECC }             from '@vbyte/micro-lib'
-import { parse_tx }        from '@/lib/tx/parse.js'
-import { SIGHASH_DEFAULT } from '@/const.js'
-import { hash_segwit_tx }  from '@/lib/sighash/segwit.js'
-import { hash_taproot_tx } from '@/lib/sighash/taproot.js'
-
-import type {
-  SigHashOptions,
-  TxData
-} from '@/types/index.js'
-
-export function sign_segwit_tx (
-  seckey  : string,
-  txdata  : TxData,
-  options : SigHashOptions,
-) {
-  const tx   = parse_tx(txdata)
-  const msg  = hash_segwit_tx(tx, options)
-  const sig  = ECC.sign_ecdsa(seckey, msg).hex
-  const flag = format_sigflag(options.sigflag ?? SIGHASH_DEFAULT)
-  return sig + flag
-}
-
-export function sign_taproot_tx (
-  seckey  : string,
-  txdata  : TxData,
-  options : SigHashOptions,
-) {
-  const tx   = parse_tx(txdata)
-  const msg  = hash_taproot_tx(tx, options)
-  const sig  = ECC.sign_bip340(seckey, msg).hex
-  const flag = format_sigflag(options.sigflag ?? 0)
-  return sig + flag
-}
-
-function format_sigflag (flag : number) {
-  return (flag !== 0) ? Buff.num(flag, 1).hex : ''
-}

package/src/lib/signer/verify.ts

@@ -1,88 +0,0 @@
-import { Bytes } from '@vbyte/buff'
-
-import type {
-  SigHashOptions,
-  TxData
-} from '@/types/index.js'
-
-export function verify_tx (
-  _txdata  : TxData | Bytes,
-  _config  : SigHashOptions = {}
-) : boolean {
-  console.warn('verify_segwit_tx is not implemented')
-  return true
-}
-
-// export function verify_signature (
-//   txdata  : TxData | Bytes,
-//   index   : number,
-//   config  : HashConfig = {}
-// ) : boolean {
-//   const tx = Tx.fmt.toJson(txdata)
-//   const { throws = false } = config
-//   const { prevout, witness = [] } = tx.vin[index]
-//   const witnessData = Tx.util.readWitness(witness)
-//   const { cblock, script, params } = witnessData
-
-//   let pub : Buff
-
-//   if (params.length < 1) {
-//     return safeThrow('Invalid witness data: ' + String(witness), throws)
-//   }
-
-//   const { scriptPubKey } = prevout ?? {}
-
-//   if (scriptPubKey === undefined) {
-//     return safeThrow('Prevout scriptPubKey is empty!', throws)
-//   }
-
-//   const { type, data: tapkey } = Tx.util.readScriptPubKey(scriptPubKey)
-
-//   if (type !== 'p2tr') {
-//     return safeThrow('Prevout script is not a valid taproot output:' + tapkey.hex, throws)
-//   }
-
-//   if (tapkey.length !== 32) {
-//     return safeThrow('Invalid tapkey length: ' + String(tapkey.length), throws)
-//   }
-
-//   if (
-//     cblock !== null &&
-//     script !== null
-//   ) {
-//     const version    = cblock[0] & 0xfe
-//     const target     = getTapLeaf(script, version)
-//     config.extension = target
-
-//     if (!checkPath(tapkey, target, cblock, { throws })) {
-//       return safeThrow('cblock verification failed!', throws)
-//     }
-//   }
-
-//   if (config.pubkey !== undefined) {
-//     pub = Buff.bytes(config.pubkey)
-//   } else if (params.length > 1 && params[1].length === 32) {
-//     pub = Buff.bytes(params[1])
-//   } else {
-//     pub = Buff.bytes(tapkey)
-//   }
-
-//   const rawsig    = Script.fmt.toParam(params[0])
-//   const stream    = new Stream(rawsig)
-//   const signature = stream.read(64).raw
-
-//   if (stream.size === 1) {
-//     config.sigflag = stream.read(1).num
-//     if (config.sigflag === 0x00) {
-//       return safeThrow('0x00 is not a valid appended sigflag!', throws)
-//     }
-//   }
-
-//   const hash = hashTx(tx, index, config)
-
-//   if (!verify(signature, hash, pub, throws)) {
-//     return safeThrow('Invalid signature!', throws)
-//   }
-
-//   return true
-// }

package/src/lib/taproot/cblock.ts

@@ -1,96 +0,0 @@
-import { Buff, Bytes }             from '@vbyte/buff'
-import { Assert, ECC }             from '@vbyte/micro-lib'
-import { merkleize }               from './tree.js'
-import { TAPLEAF_DEFAULT_VERSION } from '@/const.js'
-import * as Schema                 from '@/schema/index.js'
-
-import {
-  encode_tapbranch,
-  encode_taptweak
-} from './encode.js'
-
-import {
-  parse_pubkey_parity,
-  parse_cblock
-} from './parse.js'
-
-import {
-  TaprootConfig,
-  TaprootContext
-} from '@/types/index.js'
-
-const DEFAULT_VERSION = TAPLEAF_DEFAULT_VERSION
-
-export function create_taproot (config : TaprootConfig) : TaprootContext {
-  Schema.taproot.config.parse(config)
-
-  const { pubkey, version = DEFAULT_VERSION } = config
-
-  const leaves = config.leaves ?? []
-
-  const target = (config.target !== undefined)
-    ? Buff.bytes(config.target).hex 
-    : undefined
-
-  let path    : string[] = [],
-      taproot : string | undefined
-
-  if (leaves.length > 0) {
-    // Merkelize the leaves into a root hash (with proof).
-    const [ root, _, proofs ] = merkleize(leaves, target)
-    // Get the control path from the merkelized output.
-    path    = proofs
-    // Get the tapped key from the internal key.
-    taproot = root
-  } else {
-    // Get the tapped key from the single tapleaf.
-    taproot = target
-  }
-
-  const taptweak = encode_taptweak(pubkey, taproot)
-  const twk_key  = ECC.tweak_pubkey(pubkey, taptweak, 'ecdsa')
-  const parity   = parse_pubkey_parity(twk_key)
-  const tapkey   = ECC.serialize_pubkey(twk_key, 'bip340')
-  // Get the block version / parity bit.
-  const cbit = Buff.num(version + parity)
-  // Stack the initial control block data.
-  const block : Bytes[] = [ cbit, Buff.bytes(pubkey) ]
-  // If there is more than one path, add to block.
-  if (path.length > 0) {
-    path.forEach(e => block.push(e))
-  }
-  // Merge the data together into one array.
-  const cblock = Buff.join(block)
-
-  return {
-    int_key  : Buff.bytes(pubkey).hex,
-    path,
-    parity,
-    taproot  : taproot ?? null,
-    cblock   : cblock.hex,
-    tapkey   : tapkey.hex,
-    taptweak : taptweak.hex
-  }
-}
-
-export function verify_taproot (
-  tapkey : string,
-  target : string,
-  cblock : string
-) : boolean {
-  Assert.size(tapkey, 32)
-  const { parity, path, int_key } = parse_cblock(cblock)
-
-  const ext_key = Buff.join([ parity, tapkey ])
-
-  let branch = Buff.bytes(target).hex
-
-  for (const leaf of path) {
-    branch = encode_tapbranch(branch, leaf).hex
-  }
-
-  const tap_tweak   = encode_taptweak(int_key, branch)
-  const tweaked_key = ECC.tweak_pubkey(int_key, tap_tweak, 'ecdsa')
-
-  return (ext_key.hex === tweaked_key.hex)
-}

package/src/lib/taproot/encode.ts

@@ -1,49 +0,0 @@
-import { Buff }               from '@vbyte/buff'
-import { hash340 }            from '@vbyte/micro-lib/hash'
-import { Assert }             from '@vbyte/micro-lib'
-import { prefix_script_size } from '@/lib/script/index.js'
-
-import { TAPLEAF_DEFAULT_VERSION } from '@/const.js'
-
-const DEFAULT_VERSION = TAPLEAF_DEFAULT_VERSION
-
-export function encode_tapscript (
-  script  : string | Uint8Array,
-  version = DEFAULT_VERSION
-) : Buff {
-  const preimg = prefix_script_size(script)
-  return encode_tapleaf(preimg, version)
-}
-
-export function encode_tapleaf (
-  data : string | Uint8Array,
-  version = DEFAULT_VERSION
-) : Buff {
-  const vbyte = encode_leaf_version(version)
-  return hash340('TapLeaf', vbyte, data)
-}
-
-export function encode_tapbranch (
-  leaf_a : string,
-  leaf_b : string
-) : Buff {
-  // Compare leaves in lexical order.
-  if (leaf_b < leaf_a) {
-    // Swap leaves if needed.
-    [ leaf_a, leaf_b ] = [ leaf_b, leaf_a ]
-  }
-  // Return digest of leaves as a branch hash.
-  return hash340('TapBranch', leaf_a, leaf_b)
-}
-
-export function encode_leaf_version (version = 0xc0) : number {
-  return version & 0xfe
-}
-
-export function encode_taptweak (
-  pubkey : string | Uint8Array,
-  data   : string | Uint8Array = new Uint8Array()
-) : Buff {
-  Assert.size(pubkey, 32)
-  return hash340('TapTweak', pubkey, data)
-}

package/src/lib/taproot/index.ts

@@ -1,4 +0,0 @@
-export * from './cblock.js'
-export * from './encode.js'
-export * from './parse.js'
-export * from './tree.js'

package/src/lib/taproot/parse.ts

@@ -1,65 +0,0 @@
-import { Buff, Stream }       from '@vbyte/buff'
-import { Assert, ECC }        from '@vbyte/micro-lib'
-import { parse_witness } from '@/lib/witness/parse.js'
-
-import {
-  encode_tapbranch,
-  encode_tapscript,
-  encode_taptweak,
-} from './encode.js'
-
-import type { ControlBlock } from '@/types/index.js'
-
-export function parse_taproot_witness (witness : string[]) {
-  const { cblock, params, script } = parse_witness(witness)
-
-  Assert.exists(cblock, 'cblock is null')
-  Assert.exists(script, 'script is null')
-
-  const cblk   = parse_cblock(cblock)
-  const target = encode_tapscript(script, cblk.version)
-
-  let branch = target.hex
-
-  for (const leaf of cblk.path) {
-    branch = encode_tapbranch(branch, leaf).hex
-  }
-
-  const tweak  = encode_taptweak(cblk.int_key, branch)
-  const tapkey = ECC.tweak_pubkey(cblk.int_key, tweak, 'bip340')
-
-  params.map(e => Buff.bytes(e).hex)
-
-  return { cblock: cblk, params, script, tapkey: tapkey.hex, tweak: tweak.hex }
-}
-
-export function parse_cblock (cblock : string | Uint8Array) : ControlBlock {
-  const buffer  = new Stream(cblock)
-  const cbyte   = buffer.read(1).num
-  const int_key = buffer.read(32).hex
-  const [ version, parity ] = parse_cblock_parity(cbyte)
-  const path = []
-  while (buffer.size >= 32) {
-    path.push(buffer.read(32).hex)
-  }
-  if (buffer.size !== 0) {
-    throw new Error('Non-empty buffer on control block: ' + String(buffer))
-  }
-  return { int_key, path, parity, version }
-}
-
-export function parse_cblock_parity (cbits : number) {
-  return (cbits % 2 === 0)
-    ? [ cbits - 0, 0x02 ]
-    : [ cbits - 1, 0x03 ]
-}
-
-export function parse_pubkey_parity (
-  pubkey : string | Uint8Array
-) : number {
-  Assert.size(pubkey, 33, 'invalid pubkey size')
-  const [ parity ] = Buff.bytes(pubkey)
-  if (parity === 0x02) return 0
-  if (parity === 0x03) return 1
-  throw new Error('Invalid parity bit: ' + String(parity))
-}

package/src/lib/taproot/tree.ts

@@ -1,94 +0,0 @@
-import { Buff }             from '@vbyte/buff'
-import { encode_tapbranch } from './encode.js'
-
-import type { TapTree, MerkleProof } from '@/types/index.js'
-
-/**
- * Get the root of a taproot tree.
- * @param leaves - The leaves of the tree.
- * @returns The root of the tree.
- */
-export function get_merkle_root (leaves : TapTree) {
-  // Process the merkle tree, and return the root.
-  return merkleize(leaves)[0]
-}
-
-/**
- * Process a taproot tree into a merkle proof.
- * @param taptree - The leaves of the tree.
- * @param target  - The target leaf of the tree.
- * @param path    - The recursive path of the tree.
- * @returns The root of the tree.
- */
-export function merkleize (
-  taptree : TapTree,
-  target ?: string,
-  path    : string[] = []
-) : MerkleProof {
-  // Initialize the leaves and tree arrays.
-  const leaves : string[] = []
-  const tree   : string[] = []
-  // If there are no leaves, throw an error.
-  if (taptree.length < 1) {
-    throw new Error('Tree is empty!')
-  }
-  // Crawl through the tree, and find each leaf.
-  for (let i = 0; i < taptree.length; i++) {
-    // Get the current leaf as bytes.
-    const bytes = taptree[i]
-    // If the leaf is an array,
-    if (Array.isArray(bytes)) {
-      // Recursively process the nested tree.
-      let [ tapleaf, new_target, branches ] = merkleize(bytes, target)
-      // Update the target leaf.
-      target = new_target
-      // Add the nested tapleaf to the leaves array.
-      leaves.push(tapleaf)
-      // For each branch node,
-      for (const branch of branches) {
-        // Add the branch to the path.
-        path.push(branch)
-      }
-    } else {
-      // Convert the leaf to a hex string.
-      const leaf = Buff.bytes(bytes).hex
-      // Add the leaf to the leaves array.
-      leaves.push(leaf)
-    }
-  }
-
-  // If there is only one leaf,
-  if (leaves.length === 1) {
-    // Return the leaf as the root.
-    return [ leaves[0], target, path ]
-  }
-  // Ensure the tree is sorted at this point.
-  leaves.sort()
-  // Ensure the tree is balanced evenly.
-  if (leaves.length % 2 !== 0) {
-    // If uneven, duplicate the last leaf.
-    leaves.push(leaves[leaves.length - 1])
-  }
-  // Sort through the leaves (two at a time).
-  for (let i = 0; i < leaves.length - 1; i += 2) {
-    // Compute two leaves into a branch.
-    const branch = encode_tapbranch(leaves[i], leaves[i + 1]).hex
-    // Push our branch to the tree.
-    tree.push(branch)
-    // Check if a proof target is specified.
-    if (typeof target === 'string') {
-      // Check if this branch is part of our proofs.
-      if (target === leaves[i]) {
-        // If so, include right-side of branch.
-        path.push(leaves[i + 1])
-        target = branch
-      } else if (target === leaves[i + 1]) {
-        // If so, include left-side of branch.
-        path.push(leaves[i])
-        target = branch
-      }
-    }
-  }
-  // Recursively process the tree.
-  return merkleize(tree, target, path)
-}

package/src/lib/tx/create.ts

@@ -1,90 +0,0 @@
-import { Assert }            from '@vbyte/micro-lib'
-import { COINBASE, DEFAULT } from '@/const.js'
-
-import {
-  normalize_prevout,
-  normalize_sequence,
-  normalize_value
-} from './util.js'
-
-import {
-  assert_tx_template,
-  assert_vin_template,
-  assert_vout_template
-} from './validate.js'
-
-import type {
-  TxData,
-  TxInput,
-  TxOutput,
-  TxTemplate,
-  TxSpendInput,
-  TxCoinbaseInput,
-  TxOutputTemplate,
-  TxVirtualInput,
-  TxInputTemplate
-} from '@/types/index.js'
-
-export function create_coinbase_input (
-  config : TxInputTemplate
-) : TxCoinbaseInput {
-  assert_vin_template(config)
-  Assert.exists(config.coinbase, 'coinbase is required')
-  const txid       = COINBASE.TXID
-  const vout       = COINBASE.VOUT
-  const coinbase   = config.coinbase
-  const witness    = config.witness ?? []
-  const sequence   = normalize_sequence(config.sequence)
-  return { coinbase, prevout: null, script_sig: null, sequence, witness, txid, vout }
-}
-
-export function create_virtual_input (
-  config : TxInputTemplate
-) : TxVirtualInput {
-  assert_vin_template(config)
-  Assert.is_empty(config.coinbase, 'coinbase is not allowed')
-  Assert.is_empty(config.prevout,  'prevout is not allowed')
-  const { txid, vout, script_sig = null, witness = [] } = config
-  const sequence = normalize_sequence(config.sequence)
-  return { txid, vout, coinbase: null, prevout: null, script_sig, sequence, witness }
-}
-
-export function create_spend_input (
-  config : TxInputTemplate
-) : TxSpendInput {
-  assert_vin_template(config)
-  Assert.exists(config.prevout, 'prevout is required')
-  const { txid, vout, script_sig = null, witness = [] } = config
-  const prevout    = normalize_prevout(config.prevout)
-  const sequence   = normalize_sequence(config.sequence)
-  return { txid, vout, coinbase: null, prevout, script_sig, sequence, witness }
-}
-
-export function create_tx_input (
-  config : TxInputTemplate
-) : TxInput {
-  if (config.coinbase) return create_coinbase_input(config)
-  if (config.prevout)  return create_spend_input(config)
-  return create_virtual_input(config)
-}
-
-export function create_tx_output (
-  config : TxOutputTemplate
-) : TxOutput {
-  assert_vout_template(config)
-  const script_pk = config.script_pk
-  const value     = normalize_value(config.value)
-  return { script_pk, value }
-}
-
-export function create_tx (
-  config? : Partial<TxTemplate>
-) : TxData {
-  assert_tx_template(config)
-  const { vin = [], vout = [] } = config ?? { vin: [], vout: [] }
-  const locktime = config.locktime ?? DEFAULT.LOCKTIME
-  const version  = config.version  ?? DEFAULT.VERSION
-  const inputs   = vin.map(txin   => create_tx_input(txin))
-  const outputs  = vout.map(txout => create_tx_output(txout))
-  return { locktime, vin : inputs, vout : outputs, version }
-}

package/src/lib/tx/decode.ts

@@ -1,123 +0,0 @@
-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 {
-  TxInput,
-  TxOutput,
-  TxCoinbaseInput,
-  TxVirtualInput,
-  TxDecodedData
-} from '@/types/index.js'
-
-export function decode_tx (
-  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(txdata)
-  // Parse tx version.
-  const version = read_version(stream)
-  // Check and enable any flags that are set.
-  let has_witness = check_witness_flag(stream)
-  // If use_segwit is false, set has_witness to false.
-  has_witness = (use_segwit) ? has_witness : false
-  // Parse our inputs and outputs.
-  const vin  = read_inputs(stream)
-  const vout = read_outputs(stream)
-  // If witness flag is set, parse witness data.
-  if (has_witness) {
-    for (const txin of vin) {
-      txin.witness = read_witness(stream)
-    }
-  }
-  // Parse locktime.
-  const locktime = read_locktime(stream)
-  // Return transaction object with calculated fields.
-  return { version, vin, vout, locktime }
-}
-
-function read_version (stream : Stream) : number {
-  return stream.read(4).reverse().to_num()
-}
-
-function check_witness_flag (stream : Stream) : boolean {
-  const [ marker, flag ] : number[] = [ ...stream.peek(2) ]
-  if (marker === 0) {
-    stream.read(2)
-    if (flag === 1) {
-      return true
-    } else {
-      throw new Error(`Invalid witness flag: ${flag}`)
-    }
-  }
-  return false
-}
-
-function read_inputs (stream : Stream) : TxInput[] {
-  const inputs = []
-  const vinCount = stream.varint()
-  for (let i = 0; i < vinCount; i++) {
-    const txinput = read_vin(stream)
-    inputs.push(txinput)
-  }
-  return inputs
-}
-
-function read_vin (stream : Stream) : TxInput {
-  const txid       = stream.read(32).reverse().hex
-  const vout       = stream.read(4).reverse().num
-  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 {
-    return { coinbase : null, prevout: null, script_sig, sequence, txid, vout, witness } as TxVirtualInput
-  }
-}
-
-function read_outputs (stream : Stream) : TxOutput[] {
-  const outputs = []
-  const vcount  = stream.varint()
-  for (let i = 0; i < vcount; i++) {
-    try {
-      outputs.push(read_vout(stream))
-    } catch (error) {
-      throw new Error(`failed to decode output: ${i}: ${parse_error(error)}`)
-    }
-  }
-  return outputs
-}
-
-function read_vout (stream : Stream) : TxOutput {
-  const value     = stream.read(8).reverse().big
-  const script_pk = read_payload(stream)
-  Assert.exists(script_pk, 'failed to decode script_pk')
-  return { value, script_pk }
-}
-
-function read_witness (stream : Stream) : string[] {
-  const stack = []
-  const count = stream.varint()
-  for (let i = 0; i < count; i++) {
-    const element = read_payload(stream)
-    if (element === null) {
-      throw new Error('failed to decode witness element: ' + i)
-    }
-    stack.push(element)
-  }
-  return stack
-}
-
-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 {
-  return stream.read(4).reverse().to_num()
-}