@vbyte/btc-dev 1.1.8 → 2.0.0

package/src/lib/script/util.ts

@@ -1,78 +0,0 @@
-import { Buff } from '@vbyte/buff'
-
-export function prefix_script_size (script: string | Uint8Array): string {
-  return Buff.bytes(script).prefix_varint('le').hex
-}
-
-export function parse_script_pubkeys (script: string | Uint8Array): string[] {
-  // Convert the script to a string if it's a Uint8Array
-  const scriptHex = typeof script === 'string' ? script : Buff.bytes(script).hex
-  
-  // Define the regex pattern to match the specified pattern
-  // 20 = pushdata byte for 32 bytes (0x20)
-  // [0-9a-f]{64} = 32-byte hex string (64 hex characters)
-  // (ac|ad|ba) = OP_CHECKSIG (0xac), OP_CHECKSIGVERIFY (0xad), or OP_CHECKSIGADD (0xba)
-  const pubkeyPattern = /20([0-9a-f]{64})(ac|ad|ba)/gi
-  
-  // Find all matches in the script
-  const matches = [...scriptHex.matchAll(pubkeyPattern)]
-  
-  // Extract the public keys from the matches
-  return matches.map(match => match[1])
-}
-
-// export function parse_witness_pubkeys (
-//   witness : string[] | TxWitnessData
-// ) : string[] {
-//   // Parse the witness data if it is an array.
-//   if (witness instanceof Array) {
-//     witness = parse_witness_data(witness)
-//   }
-//   // Define the set of pubkeys.
-//   const pubkeys = new Set<string>()
-//   // Get the witness type.
-//   const type = witness.type
-//   // If the witness type is a p2tr-ts:
-//   if (type === 'p2tr-ts') {
-//     // Parse the internal pubkey from the cblock.
-//     const int_pk = witness.cblock?.slice(2, 66)
-//     // If the internal pubkey is present, add it to the list.
-//     if (int_pk !== undefined) pubkeys.add(int_pk)
-//     // Parse any pubkeys witness parameters.
-//     witness.params
-//       .filter(p => p.length === 64)
-//       .forEach(p => pubkeys.add(p))
-//     // Parse any pubkeys from the script.
-//     parse_taproot_pubkeys(witness.script!)
-//       .forEach(p => pubkeys.add(p))
-//   // If the witness type is a p2w-pkh:
-//   } else if (type === 'p2w-pkh') {
-//     // Parse the witness parameter pubkey.
-//     const params_pk = witness.params.find(p => p.length === 66)
-//     // If the parameter pubkey is present, add it to the list.
-//     if (params_pk !== undefined) pubkeys.add(params_pk)
-//   // If the witness type is a p2w-sh:
-//   } else if (type === 'p2w-sh') {
-//     // Parse any witness parameter pubkeys.
-//     witness.params
-//       .filter(p => p.length === 66)
-//       .forEach(p => pubkeys.add(p))
-//     // Parse any script pubkeys.
-//     parse_segwit_pubkeys(witness.script!)
-//       .forEach(p => pubkeys.add(p))
-//   }
-//   // Return the list of pubkeys.
-//   return Array.from(pubkeys)
-// }
-
-// function parse_segwit_pubkeys (script : string) : string[] {
-//   const regex = /21([0-9a-f]{66})(ac|ad)/gi
-//   const matches = [...script.matchAll(regex)]
-//   return matches.map(match => match[1])
-// }
-
-// function parse_taproot_pubkeys (script : string) : string[] {
-//   const regex = /20([0-9a-f]{64})(ac|ad|ba)/gi
-//   const matches = [...script.matchAll(regex)]
-//   return matches.map(match => match[1])
-// }

package/src/lib/script/words.ts

@@ -1,182 +0,0 @@
-export const OPCODE_MAP = {
-  OP_0                   : 0,
-  OP_PUSHDATA1           : 76,
-  OP_PUSHDATA2           : 77,
-  OP_PUSHDATA4           : 78,
-  OP_1NEGATE             : 79,
-  OP_SUCCESS80           : 80,
-  OP_1                   : 81,
-  OP_2                   : 82,
-  OP_3                   : 83,
-  OP_4                   : 84,
-  OP_5                   : 85,
-  OP_6                   : 86,
-  OP_7                   : 87,
-  OP_8                   : 88,
-  OP_9                   : 89,
-  OP_10                  : 90,
-  OP_11                  : 91,
-  OP_12                  : 92,
-  OP_13                  : 93,
-  OP_14                  : 94,
-  OP_15                  : 95,
-  OP_16                  : 96,
-  OP_NOP                 : 97,
-  OP_SUCCESS98           : 98,
-  OP_IF                  : 99,
-  OP_NOTIF               : 100,
-  OP_ELSE                : 103,
-  OP_ENDIF               : 104,
-  OP_VERIFY              : 105,
-  OP_RETURN              : 106,
-  OP_TOALTSTACK          : 107,
-  OP_FROMALTSTACK        : 108,
-  OP_2DROP               : 109,
-  OP_2DUP                : 110,
-  OP_3DUP                : 111,
-  OP_2OVER               : 112,
-  OP_2ROT                : 113,
-  OP_2SWAP               : 114,
-  OP_IFDUP               : 115,
-  OP_DEPTH               : 116,
-  OP_DROP                : 117,
-  OP_DUP                 : 118,
-  OP_NIP                 : 119,
-  OP_OVER                : 120,
-  OP_PICK                : 121,
-  OP_ROLL                : 122,
-  OP_ROT                 : 123,
-  OP_SWAP                : 124,
-  OP_TUCK                : 125,
-  OP_SUCCESS126          : 126,
-  OP_SUCCESS127          : 127,
-  OP_SUCCESS128          : 128,
-  OP_SUCCESS129          : 129,
-  OP_SIZE                : 130,
-  OP_SUCCESS131          : 131,
-  OP_SUCCESS132          : 132,
-  OP_SUCCESS133          : 133,
-  OP_SUCCESS134          : 134,
-  OP_EQUAL               : 135,
-  OP_EQUALVERIFY         : 136,
-  OP_SUCCESS137          : 137,
-  OP_SUCCESS138          : 138,
-  OP_1ADD                : 139,
-  OP_1SUB                : 140,
-  OP_SUCCESS141          : 141,
-  OP_SUCCESS142          : 142,
-  OP_NEGATE              : 143,
-  OP_ABS                 : 144,
-  OP_NOT                 : 145,
-  OP_0NOTEQUAL           : 146,
-  OP_ADD                 : 147,
-  OP_SUB                 : 148,
-  OP_SUCCESS149          : 149,
-  OP_SUCCESS150          : 150,
-  OP_SUCCESS151          : 151,
-  OP_SUCCESS152          : 152,
-  OP_SUCCESS153          : 153,
-  OP_BOOLAND             : 154,
-  OP_BOOLOR              : 155,
-  OP_NUMEQUAL            : 156,
-  OP_NUMEQUALVERIFY      : 157,
-  OP_NUMNOTEQUAL         : 158,
-  OP_LESSTHAN            : 159,
-  OP_GREATERTHAN         : 160,
-  OP_LESSTHANOREQUAL     : 161,
-  OP_GREATERTHANOREQUAL  : 162,
-  OP_MIN                 : 163,
-  OP_MAX                 : 164,
-  OP_WITHIN              : 165,
-  OP_RIPEMD160           : 166,
-  OP_SHA1                : 167,
-  OP_SHA256              : 168,
-  OP_HASH160             : 169,
-  OP_HASH256             : 170,
-  OP_CODESEPARATOR       : 171,
-  OP_CHECKSIG            : 172,
-  OP_CHECKSIGVERIFY      : 173,
-  OP_CHECKMULTISIG       : 174,
-  OP_CHECKMULTISIGVERIFY : 175,
-  OP_NOP1                : 176,
-  OP_CHECKLOCKTIMEVERIFY : 177,
-  OP_CHECKSEQUENCEVERIFY : 178,
-  OP_NOP4                : 179,
-  OP_NOP5                : 180,
-  OP_NOP6                : 181,
-  OP_NOP7                : 182,
-  OP_NOP8                : 183,
-  OP_NOP9                : 184,
-  OP_NOP10               : 185,
-  OP_CHECKSIGADD         : 186
-}
-
-/** 
- * Get the sting-representation of an opcode
- * based on its number value.
- */
-export function get_op_code (num : number) : string {
-  if (num > 186 && num < 255) {
-    return 'OP_SUCCESS' + String(num)
-  }
-  for (const [ k, v ] of Object.entries(OPCODE_MAP)) {
-    if (v === num) return k
-  }
-  throw new Error('OPCODE not found:' + String(num))
-}
-
-/** 
- * Get the number-representation of an opcode
- * based on its asm string value.
- */
-export function get_asm_code (string : string) : number {
-  for (const [ k, v ] of Object.entries(OPCODE_MAP)) {
-    if (k === string) return Number(v)
-  }
-  throw new Error('OPCODE not found:' + string)
-}
-
-/** 
- * Get the type of word based on its number value.
- */
-export function get_op_type (word : number) : string {
-  switch (true) {
-    case (word === 0):
-      return 'opcode'
-    case (word >= 1 && word <= 75):
-      return 'varint'
-    case (word === 76):
-      return 'pushdata1'
-    case (word === 77):
-      return 'pushdata2'
-    case (word === 78):
-      return 'pushdata4'
-    case (word <= 254):
-      return 'opcode'
-    default:
-      throw new Error(`Invalid word range: ${word}`)
-  }
-}
-
-/** 
- * Check if the provided value is a valid script opcode.
- */
-export function is_valid_op (word : number) : boolean {
-  const MIN_RANGE = 75
-  const MAX_RANGE = 254
-
-  const DISABLED_OPCODES : number[] = []
-
-  switch (true) {
-    case (typeof (word) !== 'number'):
-      return false
-    case (word === 0):
-      return true
-    case (DISABLED_OPCODES.includes(word)):
-      return false
-    case (MIN_RANGE < word && word < MAX_RANGE):
-      return true
-    default:
-      return false
-  }
-}

package/src/lib/sighash/index.ts

@@ -1,3 +0,0 @@
-export * from './segwit.js'
-export * from './taproot.js'
-export * from './util.js'

package/src/lib/sighash/segwit.ts

@@ -1,152 +0,0 @@
-import { Buff }             from '@vbyte/buff'
-import { hash160, hash256 } from '@vbyte/micro-lib/hash'
-import { Assert }           from '@vbyte/micro-lib'
-import { parse_txinput }    from './util.js'
-
-import {
-  prefix_script_size,
-  decode_script
-} from '@/lib/script/index.js'
-
-import {
-  encode_txin_vout,
-  encode_tx_locktime,
-  encode_txin_sequence,
-  encode_txin_txid,
-  encode_vout_value,
-  encode_tx_version,
-  parse_tx
-} from '@/lib/tx/index.js'
-
-import {
-  SigHashOptions,
-  TxData,
-  TxInput,
-  TxOutput
-} from '@/types/index.js'
-
-import * as CONST from '@/const.js'
-
-export function hash_segwit_tx (
-  txdata  : TxData,
-  options : SigHashOptions = {}
-) : Buff {
-  // Unpack the sigflag from our config object.
-  const { sigflag = 0x01, txindex } = options
-  // Normalize the tx into JSON format.
-  const tx = parse_tx(txdata)
-  // Check if the ANYONECANPAY flag is set.
-  const is_anypay = (sigflag & 0x80) === 0x80
-  // Save a normalized version of the sigflag.
-  const flag = sigflag % 0x80
-  // Check if the sigflag exists as a valid type.
-  if (!CONST.SIGHASH_SEGWIT.includes(flag)) {
-    throw new Error('Invalid hash type: ' + String(sigflag))
-  }
-  // Unpack the tx object.
-  const { version, vin, vout, locktime } = tx
-  // Parse the input we are signing from the config.
-  const txinput = parse_txinput(tx, options)
-  // Unpack the chosen input for signing.
-  const { txid, vout: prevIdx, prevout, sequence } = txinput
-  // Unpack the prevout for the chosen input.
-  const { value } = prevout ?? {}
-  // Check if a prevout value is provided.
-  if (value === undefined) {
-    throw new Error('Prevout value is empty!')
-  }
-  // Initialize our script variable from the config.
-  let { pubkey, script } = options
-  // Check if a pubkey is provided (instead of a script).
-  if (script === undefined && pubkey !== undefined) {
-    const pkhash = hash160(pubkey).hex
-    script = `76a914${String(pkhash)}88ac`
-  }
-  // Make sure that some form of script has been provided.
-  if (script === undefined) {
-    throw new Error('No pubkey / script has been set!')
-  }
-  // Throw if OP_CODESEPARATOR is used in a script.
-  if (decode_script(script).includes('OP_CODESEPARATOR')) {
-    throw new Error('This library does not currently support the use of OP_CODESEPARATOR in segwit scripts.')
-  }
-
-  const sighash = [
-    encode_tx_version(version),
-    bip143_hash_prevouts(vin, is_anypay),
-    bip143_hash_sequence(vin, flag, is_anypay),
-    encode_txin_txid(txid),
-    encode_txin_vout(prevIdx),
-    prefix_script_size(script),
-    encode_vout_value(value),
-    encode_txin_sequence(sequence),
-    bip143_hash_outputs(vout, flag, txindex),
-    encode_tx_locktime(locktime),
-    Buff.num(sigflag, 4).reverse()
-  ]
-
-  return hash256(Buff.join(sighash))
-}
-
-export function bip143_hash_prevouts (
-  vin : TxInput[],
-  isAnypay ?: boolean
-) : Uint8Array {
-  if (isAnypay === true) {
-    return Buff.num(0, 32)
-  }
-
-  const stack = []
-
-  for (const { txid, vout } of vin) {
-    stack.push(encode_txin_txid(txid))
-    stack.push(encode_txin_vout(vout))
-  }
-
-  return hash256(Buff.join(stack))
-}
-
-export function bip143_hash_sequence (
-  vin      : TxInput[],
-  sigflag  : number,
-  isAnyPay : boolean
-) : Uint8Array {
-  if (isAnyPay || sigflag !== 0x01) {
-    return Buff.num(0, 32)
-  }
-
-  const stack = []
-
-  for (const { sequence } of vin) {
-    stack.push(encode_txin_sequence(sequence))
-  }
-  return hash256(Buff.join(stack))
-}
-
-export function bip143_hash_outputs (
-  vout    : TxOutput[],
-  sigflag : number,
-  idx    ?: number
-) : Uint8Array {
-  const stack = []
-
-  if (sigflag === 0x01) {
-    for (const { value, script_pk } of vout) {
-      stack.push(encode_vout_value(value))
-      stack.push(prefix_script_size(script_pk))
-    }
-    return hash256(Buff.join(stack))
-  }
-
-  if (sigflag === 0x03) {
-    Assert.ok(idx !== undefined)
-    if (idx < vout.length) {
-      const { value, script_pk } = vout[idx]
-      stack.push(encode_vout_value(value))
-      stack.push(prefix_script_size(script_pk))
-      return hash256(Buff.join(stack))
-    }
-  }
-
-  return Buff.num(0, 32)
-}

package/src/lib/sighash/taproot.ts

@@ -1,206 +0,0 @@
-import { Buff }               from '@vbyte/buff'
-import { Assert }             from '@vbyte/micro-lib'
-import { hash340, sha256 }    from '@vbyte/micro-lib/hash'
-import { encode_tapscript }   from '@/lib/taproot/encode.js'
-import { parse_tx }           from '@/lib/tx/parse.js'
-import * as CONST             from '@/const.js'
-
-import {
-  parse_txinput,
-  get_annex_data,
-  get_prevout
-} from './util.js'
-
-import {
-  encode_txin_vout,
-  encode_tx_locktime,
-  encode_txin_sequence,
-  encode_txin_txid,
-  encode_vout_value,
-  encode_tx_version,
-  encode_script_data
-} from '@/lib/tx/encode.js'
-
-import type {
-  SigHashOptions,
-  TxData,
-  TxInput,
-  TxOutput
-} from '@/types/index.js'
-
-export function hash_taproot_tx (
-  template : TxData | string,
-  config   : SigHashOptions = {}
-) : Buff {
-  const preimage = get_taproot_tx_preimage(template, config)
-  return hash340('TapSighash', preimage)
-}
-
-export function get_taproot_tx_preimage (
-  template : TxData | string,
-  config   : SigHashOptions = {}
-) : Buff {
-  // Unpack configuration.
-  const {
-    script,
-    txindex,
-    sigflag       = 0x00,
-    extflag       = 0x00,
-    key_version   = 0x00,
-    separator_pos = 0xFFFFFFFF
-  } = config
-
-  // Normalize the txdata object.
-  const tx = parse_tx(template)
-  // Unpack the txdata object.
-  const { version, vin: input, vout: output, locktime } = tx
-  // Parse the input we are signing from the config.
-  const txinput = parse_txinput(tx, config)
-  // Unpack the txinput object.
-  const { txid, vout, sequence, witness = [] } = txinput
-  // Check if we are using a valid hash type.
-  if (!CONST.SIGHASH_TAPROOT.includes(sigflag)) {
-    // If the sigflag is an invalid type, throw error.
-    throw new Error('Invalid hash type: ' + String(sigflag))
-  }
-  if (extflag < 0 || extflag > 127) {
-    // If the extflag is out of range, throw error.
-    throw new Error('Extention flag out of range: ' + String(extflag))
-  }
-
-  let { extension } = config
-
-  if (script !== undefined) {
-    extension = encode_tapscript(script).hex
-  }
-
-  // Define the parameters of the transaction.
-  const is_anypay = (sigflag & 0x80) === 0x80
-  const annex     = get_annex_data(witness)
-  const annexBit  = (annex !== undefined) ? 1 : 0
-  const extendBit = (extension !== undefined) ? 1 : 0
-  const spendType = ((extflag + extendBit) * 2) + annexBit
-
-  // Begin building our preimage.
-  const preimage : (string | Uint8Array)[] = [
-    Buff.num(0x00, 1),            // Add zero-byte.
-    Buff.num(sigflag, 1),         // Commit to signature flag.
-    encode_tx_version(version),   // Commit to tx version.
-    encode_tx_locktime(locktime)  // Commit to tx locktime.
-  ]
-
-  if (!is_anypay) {
-    // If flag ANYONE_CAN_PAY is not set,
-    // then commit to all inputs.
-    const prevouts = input.map(e => get_prevout(e))
-    preimage.push(
-      bip341_hash_outpoints(input),   // Commit to txid/vout for each input.
-      bip341_hash_amounts(prevouts),  // Commit to prevout amount for each input.
-      bip341_hash_scripts(prevouts),  // Commit to prevout script for each input.
-      bip341_hash_sequence(input)     // Commit to sequence value for each input.
-    )
-  }
-
-  if ((sigflag & 0x03) < 2 || (sigflag & 0x03) > 3) {
-    // If neither SINGLE or NONE flags are set,
-    // include a commitment to all outputs.
-    preimage.push(bip341_hash_outputs(output))
-  }
-
-  // At this step, we include the spend type.
-  preimage.push(Buff.num(spendType, 1))
-
-  if (is_anypay) {
-    // If ANYONE_CAN_PAY flag is set, then we will
-    // provide a commitment to the input being signed.
-    const { value, script_pk } = get_prevout(txinput)
-    preimage.push(
-      encode_txin_txid(txid),                // Commit to the input txid.
-      encode_txin_vout(vout),                // Commit to the input vout index.
-      encode_vout_value(value),              // Commit to the input's prevout value.
-      encode_script_data(script_pk),         // Commit to the input's prevout script.
-      encode_txin_sequence(sequence)         // Commit to the input's sequence value.
-    )
-  } else {
-    // Otherwise, we must have already included a commitment
-    // to all inputs in the tx, so simply add a commitment to
-    // the index of the input we are signing for.
-    Assert.ok(typeof txindex === 'number')
-    preimage.push(Buff.num(txindex, 4).reverse())
-  }
-
-  if (annex !== undefined) {
-    // If an annex has been set, include it here.
-    preimage.push(annex)
-  }
-
-  if ((sigflag & 0x03) === 0x03) {
-    // If the SINGLE flag is set, then include a
-    // commitment to the output which is adjacent
-    // to the input that we are signing for.
-    Assert.ok(typeof txindex === 'number')
-    preimage.push(bip341_hash_output(output[txindex]))
-  }
-
-  if (extension !== undefined) {
-    // If we are extending this signature to include
-    // other commitments (such as a tapleaf), then we
-    // will add it to the preimage here.
-    preimage.push(
-      Buff.bytes(extension),           // Extention data (in bytes).
-      Buff.num(key_version),           // Key version (reserved for future upgrades).
-      Buff.num(separator_pos, 4,'le')  // If OP_CODESEPARATOR is used, this must be set.
-    )
-  }
-
-  return Buff.join(preimage)
-}
-
-export function bip341_hash_outpoints (
-  vin : TxInput[]
-) : Buff {
-  const stack = []
-  for (const { txid, vout } of vin) {
-    stack.push(encode_txin_txid(txid))
-    stack.push(encode_txin_vout(vout))
-  }
-  return sha256(Buff.join(stack))
-}
-
-export function bip341_hash_sequence (
-  vin : TxInput[]
-) : Buff {
-  return sha256(...vin.map(vin => encode_txin_sequence(vin.sequence)))
-}
-
-export function bip341_hash_amounts (
-  prevouts : TxOutput[]
-) : Buff {
-  return sha256(...prevouts.map(prevout => encode_vout_value(prevout.value)))
-}
-
-export function bip341_hash_scripts (
-  prevouts : TxOutput[]
-) : Buff {
-  return sha256(...prevouts.map(prevout => encode_script_data(prevout.script_pk)))
-}
-
-export function bip341_hash_outputs (
-  vout : TxOutput[]
-) : Buff {
-  const stack = []
-  for (const { value, script_pk } of vout) {
-    stack.push(encode_vout_value(value))
-    stack.push(encode_script_data(script_pk))
-  }
-  return sha256(...stack)
-}
-
-export function bip341_hash_output (
-  vout : TxOutput
-) : Buff {
-  return sha256(
-    encode_vout_value(vout.value),
-    encode_script_data(vout.script_pk)
-  )
-}

package/src/lib/sighash/util.ts

@@ -1,51 +0,0 @@
-import { Buff }   from '@vbyte/buff'
-import { Assert } from '@vbyte/micro-lib'
-import { sha256 } from '@vbyte/micro-lib/hash'
-
-import type {
-  SigHashOptions,
-  TxInput,
-  TxData,
-  TxOutput,
-} from '@/types/index.js'
-
-export function get_prevout (vin : TxInput) : TxOutput {
-  Assert.exists(vin.prevout, 'Prevout data missing for input: ' + String(vin.txid))
-  return vin.prevout
-}
-
-export function parse_txinput (
-  txdata  : TxData,
-  config ?: SigHashOptions
-) : TxInput {
-  let { txindex, txinput } = config ?? {}
-  if (txindex !== undefined) {
-    if (txindex >= txdata.vin.length) {
-      // If index is out of bounds, throw error.
-      throw new Error('Input index out of bounds: ' + String(txindex))
-    }
-    txinput = txdata.vin.at(txindex)
-  }
-  Assert.ok(txinput !== undefined)
-  return txinput
-}
-
-export function get_annex_data (
-  witness ?: string[]
-) : Buff | undefined {
-  // If no witness exists, return undefined.
-  if (witness === undefined) return
-  // If there are less than two elements, return undefined.
-  if (witness.length < 2) return
-  // Define the last element as the annex.
-  const annex = witness.at(-1)
-  // If the annex is a string and starts with '50',
-  if (typeof annex === 'string' && annex.startsWith('50')) {
-    // Convert the annex to a buffer with a varint prefix.
-    const bytes = Buff.hex(annex).prefix_varint('be')
-    // Return the sha256 of the annex.
-    return sha256(bytes)
-  }
-  // Else, return undefined.
-  return undefined
-}

package/src/lib/signer/index.ts

@@ -1,2 +0,0 @@
-export * from './sign.js'
-export * from './verify.js'