@vbyte/btc-dev 1.0.0

package/src/lib/psbt/util.ts

@@ -0,0 +1,62 @@
+import { Assert }     from '@vbyte/micro-lib'
+import { parse_psbt } from './encoder.js'
+
+import type {
+  PSBTData,
+  PSBTInput,
+  PSBTOutput,
+  PSBTPrevouts
+} from '@/types/index.js'
+
+export function collect_vins (
+  psbt : string | PSBTData
+) : PSBTInput[] {
+  const pdata = parse_psbt(psbt)
+  const count = pdata.inputsLength
+  const vins : PSBTInput[] = []
+  for (let i = 0; i < count; i++) {
+    const vin = pdata.getInput(i)
+    vins.push(vin)
+  }
+  return vins
+}
+
+export function collect_vouts (
+  psbt : string | PSBTData
+) : PSBTOutput[] {
+  const pdata = parse_psbt(psbt)
+  const count = pdata.outputsLength
+  const vouts : PSBTOutput[] = []
+  for (let i = 0; i < count; i++) {
+    const vout = pdata.getOutput(i)
+    vouts.push(vout)
+  }
+  return vouts
+}
+
+export function collect_prevouts (
+  psbt : PSBTData
+) : PSBTPrevouts {
+  const amounts : bigint[]     = [],
+        scripts : Uint8Array[] = []
+  const pdata = parse_psbt(psbt)
+  for (let i = 0; i < pdata.inputsLength; i++) {
+    const txin = pdata.getInput(i)
+    Assert.exists(txin.witnessUtxo, `witness utxo does not exist for input ${i}`)
+    amounts.push(txin.witnessUtxo.amount)
+    scripts.push(txin.witnessUtxo.script)
+  }
+  return { amounts, scripts }
+}
+
+export function finalize_legacy_inputs (pdata : PSBTData) {
+  for (let i = 0; i < pdata.inputsLength; i++) {
+    const pvin   = pdata.getInput(i)
+    const script = pvin.redeemScript
+    const psig   = pvin.partialSig?.at(0)
+    if (script !== undefined && psig !== undefined) {
+      pdata.finalizeIdx(i)
+    }
+  }
+  return pdata
+}

package/src/lib/psbt/validate.ts

@@ -0,0 +1,18 @@
+import { Assert }     from '@vbyte/micro-lib'
+import { parse_psbt } from './encoder.js'
+
+import {
+  collect_vins,
+  collect_vouts
+} from './util.js'
+
+import type { PSBTData } from '@/types/index.js'
+
+export function assert_psbt_is_funded (psbt : string | PSBTData) : void {
+  const pdata   = parse_psbt(psbt)
+  const pvouts  = collect_vins(pdata)
+  const txouts  = collect_vouts(pdata)
+  const vin_amt = pvouts.reduce((p, n) => p + Number(n.witnessUtxo?.amount ?? 0), 0)
+  const out_amt = txouts.reduce((p, n) => p + Number(n.amount ?? 0), 0)
+  Assert.ok(vin_amt >= out_amt, `value in (${vin_amt}) < value out (${out_amt})`)
+}

package/src/lib/script/decode.ts

@@ -0,0 +1,75 @@
+import { Stream } from '@vbyte/buff'
+
+import {
+  get_op_code,
+  get_op_type,
+  is_valid_op
+} from './words.js'
+
+/**
+ * Decode a bitcoin script into asm instructions.
+ */
+export function decode_script (
+  script : string | Uint8Array
+) : string[] {
+  const stream = new Stream(script)
+
+  const stack : string[] = []
+  const stack_size = stream.size
+
+  let word      : number
+  let word_type : string
+  let word_size : number
+
+  let count = 0
+
+  while (count < stack_size) {
+    word = stream.read(1).num
+    word_type = get_op_type(word)
+    count++
+    switch (word_type) {
+      case 'varint':
+        stack.push(stream.read(word).hex)
+        count += word
+        break
+      case 'pushdata1':
+        word_size = stream.read(1).reverse().num
+        stack.push(stream.read(word_size).hex)
+        count += word_size + 1
+        break
+      case 'pushdata2':
+        word_size = stream.read(2).reverse().num
+        stack.push(stream.read(word_size).hex)
+        count += word_size + 2
+        break
+      case 'pushdata4':
+        word_size = stream.read(4).reverse().num
+        stack.push(stream.read(word_size).hex)
+        count += word_size + 4
+        break
+      case 'opcode':
+        if (!is_valid_op(word)) {
+          throw new Error(`Invalid OPCODE: ${word}`)
+        }
+        stack.push(get_op_code(word))
+        break
+      default:
+        throw new Error(`Word type undefined: ${word}`)
+    }
+  }
+  return stack
+}
+
+/**
+ * Check if a script is valid.
+ */
+export function is_valid_script (
+  script : string | Uint8Array
+) : boolean {
+  try {
+    const stack = decode_script(script)
+    return stack.length > 0
+  } catch {
+    return false
+  }
+}

package/src/lib/script/encode.ts

@@ -0,0 +1,130 @@
+import { Buff, Stream }  from '@vbyte/buff'
+import { get_asm_code, } from './words.js'
+
+// The maximum size of a word in bytes.
+const MAX_WORD_SIZE = 520
+
+/**
+ * Encode script asm instructions into a hex string.
+ */
+export function encode_script (
+  words : (string | number | Uint8Array)[],
+  varint = false
+) : string {
+  if (words.length === 0) return '00'
+
+  const bytes = []
+
+  for (const word of words) {
+
+    bytes.push(encode_script_word(word))
+  }
+
+  const buffer = Buff.join(bytes)
+
+  return (varint)
+    ? buffer.prepend(Buff.varint(buffer.length, 'le')).hex
+    : buffer.hex
+}
+
+
+/** Check if the word is a valid opcode,
+ *  and return its integer value.
+ */
+export function encode_script_word (word : string | number | Uint8Array) : Uint8Array {
+  let buff : Buff
+
+  // If word is a string:
+  if (typeof (word) === 'string') {
+    // If word is an opcode:
+    if (word.startsWith('OP_')) {
+      // Get the opcode number value.
+      const asm_code = get_asm_code(word)
+      // Return the opcode as a single byte.
+      return Buff.num(asm_code, 1)
+    // If word is valid hex:
+    } else if (Buff.is_hex(word)) {
+      // Encode as hex.
+      buff = Buff.hex(word)
+    } else {
+      // Encode as UTF8 string.
+      buff = Buff.str(word)
+    }
+  // If word is a number:
+  } else if (typeof (word) === 'number') {
+    // Encode the number value.
+    buff = Buff.num(word)
+  // If word is a Uint8Array:
+  } else if (word instanceof Uint8Array) {
+    // Encode as bytes.
+    buff = new Buff(word)
+  } else {
+    // If word is not a string, number, or Uint8Array, throw an error.
+    throw new Error('invalid word type:' + typeof (word))
+  }
+
+  // Format and return the word based on its size.
+  if (buff.length === 1 && buff[0] <= 16) {
+    // Number values 0-16 must be treated as opcodes.
+    if (buff[0] !== 0) buff[0] += 0x50
+  } else if (buff.length > MAX_WORD_SIZE) {
+    // Number values larger than max size must be split into chunks.
+    let words : Buff[]
+    // Split bytes into chunks, based on max word size.
+    words = split_script_word(buff)
+    // Prefix a varint length byte for each chunk.
+    words = words.map(e => prefix_word_size(e))
+    // Concatenate the chunks
+    buff = Buff.join(words)
+  } else {
+    // Else, return the word with a varint prefix.
+    buff = prefix_word_size(buff)
+  }
+  // Return the final result.
+  return buff
+}
+
+/**
+ * Split a word into smaller chunks.
+ */
+export function split_script_word (
+  word : Uint8Array
+) : Buff[] {
+  const words = []
+  const buff  = new Stream(word)
+  while (buff.size > MAX_WORD_SIZE) {
+    // Push a word chunk to the array.
+    words.push(buff.read(MAX_WORD_SIZE))
+  }
+  // Push the remainder to the array.
+  words.push(buff.read(buff.size))
+  return words
+}
+
+/**
+ * Prefix a word with its size, encoded as a varint.
+ */
+export function prefix_word_size (
+  word : Uint8Array
+) : Buff {
+  const varint = get_size_varint(word.length)
+  return Buff.join([ varint, word ])
+}
+
+/**
+ * Return a varint that encodes a size value.
+ */
+export function get_size_varint (size : number) : Buff {
+  const OP_PUSHDATA1 = Buff.num(0x4c, 1)
+  const OP_PUSHDATA2 = Buff.num(0x4d, 1)
+  switch (true) {
+    case (size <= 0x4b):
+      return Buff.num(size)
+    case (size > 0x4b && size < 0x100):
+      return Buff.join([ OP_PUSHDATA1, Buff.num(size, 1, 'le') ])
+    case (size >= 0x100 && size <= MAX_WORD_SIZE):
+      return Buff.join([ OP_PUSHDATA2, Buff.num(size, 2, 'le') ])
+    default:
+      throw new Error('Invalid word size:' + size.toString())
+  }
+}

package/src/lib/script/index.ts

@@ -0,0 +1,26 @@
+import { OPCODE_MAP }    from './words.js'
+import { encode_script } from './encode.js'
+
+import {
+  decode_script,
+  is_valid_script
+} from './decode.js'
+
+import {
+  parse_script_pubkeys,
+  prefix_script_size
+} from './util.js'
+
+export * from './decode.js'
+export * from './encode.js'
+export * from './util.js'
+export * from './words.js'
+
+export namespace ScriptUtil {
+  export const prefix_size = prefix_script_size
+  export const decode      = decode_script
+  export const encode      = encode_script
+  export const is_valid    = is_valid_script
+  export const get_pubkeys = parse_script_pubkeys
+  export const OPCODES     = OPCODE_MAP
+}

package/src/lib/script/util.ts

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,182 @@
+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

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