@vbyte/btc-dev 1.1.8 → 2.1.0

package/src/lib/address/p2wpkh.ts

@@ -1,94 +0,0 @@
-import { Buff, Bytes }        from '@vbyte/buff'
-import { Assert }             from '@vbyte/micro-lib'
-import { hash160 }            from '@vbyte/micro-lib/hash'
-import { encode_address }     from './encode.js'
-import { is_p2wpkh_script }   from '@/lib/script/lock.js'
-import { LOCK_SCRIPT_TYPE }   from '@/const.js'
-
-import {
-  get_address_config,
-  get_address_info
-} from './util.js'
-
-import type {
-  AddressInfo,
-  ChainNetwork
-} from '@/types/index.js'
-
-const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2WPKH
-
-export namespace P2WPKH {
-  export const create_address = create_p2wpkh_address
-  export const create_script  = create_p2wpkh_script
-  export const encode_address = encode_p2wpkh_address
-  export const encode_script  = encode_p2wpkh_script
-  export const decode_address = decode_p2wpkh_address
-  export const decode_script  = decode_p2wpkh_script
-}
-
-function create_p2wpkh_address (
-  pubkey  : Bytes,
-  network : ChainNetwork = 'main',
-) : string {
-  // Create the p2wpkh script.
-  const script = create_p2wpkh_script(pubkey)
-  // Encode the script as an address.
-  return encode_p2wpkh_address(script, network)
-}
-
-function create_p2wpkh_script (pubkey : Bytes) : Buff {
-  // Convert the public key into bytes.
-  const bytes = Buff.bytes(pubkey)
-  // Assert the public key is 33 bytes.
-  Assert.size(bytes, 33, 'invalid pubkey size')
-  // Convert the bytes into a hash.
-  const hash = hash160(bytes)
-  // Return the script.
-  return encode_p2wpkh_script(hash)
-}
-
-function encode_p2wpkh_script (pk_hash : Bytes) : Buff {
-  return Buff.join([ '0014', pk_hash ])
-}
-
-function encode_p2wpkh_address (
-  script_pk : Bytes,
-  network   : ChainNetwork = 'main',
-) : string {
-  // Get the public key hash from the script.
-  const pk_hash = decode_p2wpkh_script(script_pk)
-  // Get the address configuration.
-  const config = get_address_config(network, ADDRESS_TYPE)
-  // Assert the configuration exists.
-  Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE} on ${network}` )
-  // Assert the payload size is correct.
-  Assert.size(pk_hash, config.size, `invalid payload size: ${pk_hash.length} !== ${config.size}` )
-  // Encode the address.
-  return encode_address({
-    data   : pk_hash,
-    format : 'bech32',
-    prefix : config.prefix
-  })
-}
-
-function decode_p2wpkh_address (
-  address : string
-) : AddressInfo {
-  // Parse the address.
-  const parsed = get_address_info(address)
-  // Assert the address type is correct.
-  Assert.ok(parsed.type === 'p2wpkh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`)
-  // Return the parsed address.
-  return parsed
-}
-
-function decode_p2wpkh_script (
-  script  : Bytes,
-) : Buff {
-  // Assert the script is a p2wpkh script.
-  Assert.ok(is_p2wpkh_script(script), `invalid p2wpkh script`)
-  // Convert the script into bytes.
-  const bytes = Buff.bytes(script)
-  // Return the public key hash from the script.
-  return bytes.slice(2, 22)
-}

package/src/lib/address/p2wsh.ts

@@ -1,92 +0,0 @@
-import { Buff, Bytes }        from '@vbyte/buff'
-import { Assert }             from '@vbyte/micro-lib'
-import { sha256 }             from '@vbyte/micro-lib/hash'
-import { encode_address }     from './encode.js'
-import { is_p2wsh_script }    from '@/lib/script/lock.js'
-import { LOCK_SCRIPT_TYPE }   from '@/const.js'
-
-import {
-  get_address_config,
-  get_address_info
-} from './util.js'
-
-import type {
-  AddressInfo,
-  ChainNetwork
-} from '@/types/index.js'
-
-const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2WSH
-
-export namespace P2WSH {
-  export const create_address = create_p2wsh_address
-  export const create_script  = create_p2wsh_script
-  export const encode_address = encode_p2wsh_address
-  export const encode_script  = encode_p2wsh_script
-  export const decode_address = decode_p2wsh_address
-  export const decode_script  = decode_p2wsh_script
-}
-
-function create_p2wsh_address (
-  script  : Bytes,
-  network : ChainNetwork = 'main',
-) : string {
-  // Create the p2wsh script.
-  const wsh_script = create_p2wsh_script(script)
-  // Encode the script as an address.
-  return encode_p2wsh_address(wsh_script, network)
-}
-
-function create_p2wsh_script (script : Bytes) : Buff {
-  // Convert the script into bytes.
-  const bytes = Buff.bytes(script)
-  // Convert the bytes into a hash.
-  const hash = sha256(bytes)
-  // Return the script.
-  return encode_p2wsh_script(hash)
-}
-
-function encode_p2wsh_script (script_hash : Bytes) : Buff {
-  return Buff.join([ '0020', script_hash ])
-}
-
-function encode_p2wsh_address (
-  script_pk : Bytes,
-  network   : ChainNetwork = 'main',
-) : string {
-  // Get the script hash from the script.
-  const script_hash = decode_p2wsh_script(script_pk)
-  // Get the address configuration.
-  const config = get_address_config(network, ADDRESS_TYPE)
-  // Assert the configuration exists.
-  Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE} on ${network}` )
-  // Assert the payload size is correct.
-  Assert.size(script_hash, config.size, `invalid payload size: ${script_hash.length} !== ${config.size}` )
-  // Encode the address.
-  return encode_address({
-    data   : script_hash,
-    format : 'bech32',
-    prefix : config.prefix
-  })
-}
-
-function decode_p2wsh_address (
-  address : string
-) : AddressInfo {
-  // Parse the address.
-  const parsed = get_address_info(address)
-  // Assert the address type is correct.
-  Assert.ok(parsed.type === 'p2wsh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`)
-  // Return the parsed address.
-  return parsed
-}
-
-function decode_p2wsh_script (
-  script  : Bytes,
-) : Buff {
-  // Assert the script is a p2wsh script.
-  Assert.ok(is_p2wsh_script(script), `invalid p2wsh script`)
-  // Convert the script into bytes.
-  const bytes = Buff.bytes(script)
-  // Return the script hash from the script.
-  return bytes.slice(2, 34)
-}

package/src/lib/address/script.ts

@@ -1,63 +0,0 @@
-import type { AddressType, ScriptInfo } from '@/types/index.js'
-
-/**
- * Get the address script.
- * 
- * @param script_key  - The script key.
- * @param script_type - The script type.
- * @returns The address script.
- */
-export function get_address_script (
-  script_key  : string,
-  script_type : AddressType
-) : ScriptInfo {
-  switch (script_type) {
-    case 'p2pkh':
-      return get_p2pkh_script(script_key)
-    case 'p2sh':
-      return get_p2sh_script(script_key)
-    case 'p2wpkh':
-      return get_p2w_pkh_script(script_key)
-    case 'p2wsh':
-      return get_p2w_sh_script(script_key)
-    case 'p2tr':
-      return get_p2tr_script(script_key)
-    default:
-      throw new Error('unrecognized script type: ' + script_type)
-  }
-}
-
-function get_p2pkh_script (script_key : string) {
-  return {
-    hex : '76a914' + script_key + '88ac',
-    asm : [ 'OP_DUP', 'OP_HASH160', script_key, 'OP_EQUALVERIFY', 'OP_CHECKSIG' ]
-  }
-}
-
-function get_p2sh_script (script_key : string) {
-  return {
-    hex : 'a914' + script_key + '87',
-    asm : [ 'OP_HASH160', script_key, 'OP_EQUAL' ]
-  }
-}
-
-function get_p2w_pkh_script (script_key : string) {
-  return {
-    hex : '0014' + script_key,
-    asm : [ 'OP_0', script_key ]
-  }
-}
-
-function get_p2w_sh_script (script_key : string) {
-  return {
-    hex : '0020' + script_key,
-    asm : [ 'OP_0', script_key ]
-  }
-}
-
-function get_p2tr_script (script_key : string) {
-  return {
-    hex : '5120' + script_key,
-    asm : [ 'OP_1', script_key ]
-  }
-}

package/src/lib/address/util.ts

@@ -1,87 +0,0 @@
-import { Buff }               from '@vbyte/buff'
-import { decode_address }     from './encode.js'
-import { get_address_script } from './script.js'
-
-import type {
-  AddressConfig,
-  AddressConfigEntry,
-  AddressInfo,
-  ChainNetwork,
-  LockScriptType,
-} from '@/types/index.js'
-
-const CONFIG_TABLE : AddressConfigEntry[] = [
-  [ '1',      'p2pkh',   'main',    20, 'base58',  0x00 ],
-  [ '3',      'p2sh',    'main',    20, 'base58',  0x05 ],
-  [ 'm',      'p2pkh',   'testnet', 20, 'base58',  0x6F ],
-  [ 'n',      'p2pkh',   'testnet', 20, 'base58',  0x6F ],
-  [ '2',      'p2sh',    'testnet', 20, 'base58',  0xC4 ],
-  [ 'm',      'p2pkh',   'regtest', 20, 'base58',  0x6F ],
-  [ 'n',      'p2pkh',   'regtest', 20, 'base58',  0x6F ],
-  [ '2',      'p2sh',    'regtest', 20, 'base58',  0xC4 ],
-  [ 'bc',     'p2wpkh', 'main',    20, 'bech32',  0    ],
-  [ 'tb',     'p2wpkh', 'testnet', 20, 'bech32',  0    ],
-  [ 'bcrt',   'p2wpkh', 'regtest', 20, 'bech32',  0    ],
-  [ 'bc',     'p2wsh',  'main',    32, 'bech32',  0    ],
-  [ 'tb',     'p2wsh',  'testnet', 32, 'bech32',  0    ],
-  [ 'bcrt',   'p2wsh',  'regtest', 32, 'bech32',  0    ],
-  [ 'bc',     'p2tr',    'main',    32, 'bech32m', 1    ],
-  [ 'tb',     'p2tr',    'testnet', 32, 'bech32m', 1    ],
-  [ 'bcrt',   'p2tr',    'regtest', 32, 'bech32m', 1    ]
-]
-
-/**
- * Lookup an address configuration by its type and network.
- * 
- * @param address_network - The network of the address.
- * @param address_type    - The type of the address.
- * @returns The address information, or null if the address is not recognized.
- */
-export function get_address_config (
-  address_network : ChainNetwork,
-  address_type    : LockScriptType
-) : AddressConfig | null {
-  // For each configuration in the table,
-  for (const [ prefix, type, network, size, format, version ] of CONFIG_TABLE) {
-    // Check if the address matches the configuration
-    if (type === address_type && network === address_network) {
-      // Return the address configuration.
-      return { type, prefix, network, size, format, version }
-    }
-  }
-  // If no configuration matches the address, return null.
-  return null
-}
-
-/**
- * Parse an address into its data and script.
- * 
- * @param address - The address to parse.
- * @returns The address data and script.
- */
-export function get_address_info (address : string) : AddressInfo {
-  // Decode the address.
-  const dec = decode_address(address)
-  // For each configuration in the table,
-  for (const [ prefix, type, network, size, format, version ] of CONFIG_TABLE) {
-
-    // Check if the address matches the configuration
-    if (format  !== dec.format)      continue
-    if (size    !== dec.data.length) continue
-    if (version !== dec.version)     continue
-
-    if (dec.prefix) {
-      if (prefix !== dec.prefix) continue
-    } else {
-      if (!address.startsWith(prefix)) continue
-    }
-
-    // Convert the decoded data into a hex string.
-    const data   = Buff.uint(dec.data).hex
-    const script = get_address_script(data, type)
-    // Return the address configuration and data.
-    return { data, script,type, prefix, network, size, format, version }
-  }
-  // Otherwise, throw an error
-  throw new Error('address configuration is invalid')
-}

package/src/lib/meta/index.ts

@@ -1,4 +0,0 @@
-export * from './locktime.js'
-export * from './ref.js'
-export * from './scribe.js'
-export * from './sequence.js'

package/src/lib/meta/locktime.ts

@@ -1,57 +0,0 @@
-import { Assert } from '@vbyte/micro-lib'
-
-import type { LocktimeData } from '@/types/index.js'
-
-// The threshold between block height and timestamp.
-const LOCKTIME_THRESHOLD = 500000000
-
-export namespace LocktimeField {
-  export const encode = encode_locktime
-  export const decode = decode_locktime
-}
-
-/**
- * Encodes a LockTimeData object into a string representation.
- * According to BIP-65, the value is simply the numeric value as a string.
- */
-export function encode_locktime (
-  locktime : LocktimeData
-) : number {
-  switch (locktime.type) {
-    case 'timelock':
-      Assert.ok(locktime.stamp >= LOCKTIME_THRESHOLD, 'Invalid timestamp')
-      return locktime.stamp
-    case 'heightlock':
-      Assert.ok(locktime.height > 0,                  'height must be greater than 0')
-      Assert.ok(locktime.height < LOCKTIME_THRESHOLD, 'invalid block height')
-      return locktime.height
-    default:
-      throw new Error('Invalid locktime type')
-  }
-}
-
-/**
- * Parses a string or number into a LockTimeData object.
- * According to BIP-65, values below LOCKTIME_THRESHOLD are interpreted as block heights,
- * while values at or above this threshold are interpreted as timestamps.
- */
-export function decode_locktime (
-  locktime : number
-) : LocktimeData | null {
-  // Check if the value is valid (non-negative)
-  if (isNaN(locktime) || locktime <= 0) {
-    return null
-  }
-  // Return the appropriate locktime type.
-  if (locktime < LOCKTIME_THRESHOLD) {
-    return {
-      type   : 'heightlock',
-      height : locktime
-    }
-  } else {
-    return {
-      type  : 'timelock',
-      stamp : locktime
-    }
-  }
-}

package/src/lib/meta/ref.ts

@@ -1,107 +0,0 @@
-export namespace RefPointer {
-  export const outpoint = {
-    encode : encode_outpoint,
-    decode : decode_outpoint,
-    verify : verify_outpoint, 
-    assert : assert_outpoint,
-  }
-  export const record_id = {
-    encode : encode_inscription_id,
-    decode : decode_inscription_id,
-    verify : verify_inscription_id,
-    assert : assert_inscription_id,
-  }
-  export const rune_id = {
-    encode : encode_rune_id,
-    decode : decode_rune_id,
-    verify : verify_rune_id,
-    assert : assert_rune_id,
-  }
-}
-
-function encode_inscription_id (
-  txid  : string,
-  order : number = 0
-) : string {
-  return `${txid}i${order}`
-}
-
-function decode_inscription_id (
-  inscription_id : string
-) : { txid : string, order : number } {
-  assert_inscription_id(inscription_id)
-  const [ txid, order ] = inscription_id.split('i')
-  return { txid, order : parseInt(order) }
-}
-
-function verify_inscription_id (
-  inscription_id : string
-) : boolean {
-  return inscription_id.match(/^[a-f0-9]{64}i\d+$/) !== null
-}
-
-function assert_inscription_id (
-  inscription_id : string
-) : void {
-  if (!verify_inscription_id(inscription_id)) {
-    throw new Error(`invalid inscription id: ${inscription_id}`)
-  }
-}
-
-function encode_rune_id (
-  block_height : number,
-  block_index  : number
-) : string {
-  return `${block_height}:${block_index}`
-}
-
-function decode_rune_id (
-  rune_id : string
-) : { block_height : number, block_index : number } {
-  assert_rune_id(rune_id)
-  const [ block_height, block_index ] = rune_id.split(':')
-  return { block_height : parseInt(block_height), block_index : parseInt(block_index) }
-}
-
-function verify_rune_id (
-  rune_id : string
-) : boolean {
-  return rune_id.match(/^\d+:\d+$/) !== null
-}
-
-function assert_rune_id (
-  rune_id : string
-) : void {
-  if (!verify_rune_id(rune_id)) {
-    throw new Error(`invalid rune id: ${rune_id}`)
-  }
-}
-
-function encode_outpoint (
-  txid  : string,
-  vout  : number
-) : string {
-  return `${txid}:${vout}`
-}
-
-function decode_outpoint (
-  outpoint : string
-) : { txid : string, vout : number } {
-  assert_outpoint(outpoint)
-  const [ txid, vout ] = outpoint.split(':')
-  return { txid, vout : parseInt(vout) }
-}
-
-function verify_outpoint (
-  outpoint : string
-) : boolean {
-  return outpoint.match(/^[a-f0-9]{64}:[0-9]+$/) !== null
-}
-
-function assert_outpoint (
-  outpoint : string
-) : void {
-  if (!verify_outpoint(outpoint)) {
-    throw new Error(`invalid outpoint: ${outpoint}`)
-  }
-}