@vbyte/btc-dev 1.1.3 → 1.1.5

package/src/lib/address/p2tr.ts

@@ -1,39 +1,68 @@
-import { Buff }           from '@vbyte/buff'
-import { Assert }         from '@vbyte/micro-lib'
-import { encode_address } from './encode.js'
+import { Buff, Bytes }        from '@vbyte/buff'
+import { Assert }             from '@vbyte/micro-lib'
+import { encode_address }     from './encode.js'
+import { is_p2tr_script }     from '@/lib/script/lock.js'
+import { LOCK_SCRIPT_TYPE }   from '@/const.js'
 
 import {
   get_address_config,
-  parse_address
+  get_address_info
 } from './util.js'
 
 import type {
-  ChainNetwork,
-  AddressData
+  AddressInfo,
+  ChainNetwork
 } from '@/types/index.js'
 
-const ADDR_TYPE = 'p2tr'
+const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2TR
 
 export namespace P2TR {
-  export const encode = encode_p2tr_address
-  export const decode = decode_p2tr_address
+  export const create_address = create_p2tr_address
+  export const create_script  = create_p2tr_script
+  export const encode_address = encode_p2tr_address
+  export const encode_script  = encode_p2tr_script
+  export const decode_address = decode_p2tr_address
+  export const decode_script  = decode_p2tr_script
 }
 
-function encode_p2tr_address (
-  pubkey  : string | Uint8Array,
-  network : ChainNetwork = 'main'
+function create_p2tr_address (
+  pubkey  : Bytes,
+  network : ChainNetwork = 'main',
 ) : string {
+  // Create the p2tr script.
+  const script = create_p2tr_script(pubkey)
+  // Encode the script as an address.
+  return encode_p2tr_address(script, network)
+}
+
+function create_p2tr_script (pubkey : Bytes) : Buff {
   // Convert the public key into bytes.
   const bytes = Buff.bytes(pubkey)
+  // Assert the public key is 32 bytes.
+  Assert.size(bytes, 32, 'invalid pubkey size')
+  // Return the script.
+  return encode_p2tr_script(bytes)
+}
+
+function encode_p2tr_script (pubkey : Bytes) : Buff {
+  return Buff.join([ '5120', pubkey ])
+}
+
+function encode_p2tr_address (
+  script_pk : Bytes,
+  network   : ChainNetwork = 'main'
+) : string {
+  // Get the public key from the script.
+  const pubkey = decode_p2tr_script(script_pk)
   // Get the address configuration.
-  const config = get_address_config(network, ADDR_TYPE)
+  const config = get_address_config(network, ADDRESS_TYPE)
   // Assert the configuration exists.
-  Assert.exists(config, `unrecognized address config: ${ADDR_TYPE} on ${network}` )
+  Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE} on ${network}` )
   // Assert the payload size is correct.
-  Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}` )
+  Assert.size(pubkey, config.size, `invalid payload size: ${pubkey.length} !== ${config.size}` )
   // Encode the address.
   return encode_address({
-    data   : bytes,
+    data   : pubkey,
     format : 'bech32m',
     prefix : config.prefix
   })
@@ -41,11 +70,22 @@ function encode_p2tr_address (
 
 function decode_p2tr_address (
   address : string
-) : AddressData {
+) : AddressInfo {
   // Parse the address.
-  const parsed = parse_address(address)
+  const parsed = get_address_info(address)
   // Assert the address type is correct.
-  Assert.ok(parsed.type === 'p2tr', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE}`)
+  Assert.ok(parsed.type === 'p2tr', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`)
   // Return the parsed address.
   return parsed
 }
+
+function decode_p2tr_script (
+  script  : Bytes,
+) : Buff {
+  // Assert the script is a p2tr script.
+  Assert.ok(is_p2tr_script(script), `invalid p2tr script`)
+  // Convert the script into bytes.
+  const bytes = Buff.bytes(script)
+  // Return the public key from the script.
+  return bytes.slice(2, 34)
+}

package/src/lib/address/p2wpkh.ts

@@ -1,55 +1,71 @@
-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 { 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,
-  parse_address
+  get_address_info
 } from './util.js'
 
 import type {
-  AddressData,
+  AddressInfo,
   ChainNetwork
 } from '@/types/index.js'
 
-const ADDR_TYPE = 'p2w-pkh'
+const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2WPKH
 
 export namespace P2WPKH {
-  export const create = create_p2wpkh_address
-  export const encode = encode_p2wpkh_address
-  export const decode = decode_p2wpkh_address
+  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  : string | Uint8Array,
+  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 payload size is correct.
-  Assert.size(bytes, 33, `invalid payload size: ${bytes.length} !== 33` )
+  // Assert the public key is 33 bytes.
+  Assert.size(bytes, 33, 'invalid pubkey size')
   // Convert the bytes into a hash.
   const hash = hash160(bytes)
-  // Encode the address.
-  return encode_p2wpkh_address(hash, network)
+  // 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 (
-  pk_hash : string | Uint8Array,
-  network : ChainNetwork = 'main',
+  script_pk : Bytes,
+  network   : ChainNetwork = 'main',
 ) : string {
-  // Convert the public key hash into bytes.
-  const bytes  = Buff.bytes(pk_hash)
+  // 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, ADDR_TYPE)
+  const config = get_address_config(network, ADDRESS_TYPE)
   // Assert the configuration exists.
-  Assert.exists(config, `unrecognized address config: ${ADDR_TYPE} on ${network}` )
+  Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE} on ${network}` )
   // Assert the payload size is correct.
-  Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}` )
+  Assert.size(pk_hash, config.size, `invalid payload size: ${pk_hash.length} !== ${config.size}` )
   // Encode the address.
   return encode_address({
-    data   : bytes,
+    data   : pk_hash,
     format : 'bech32',
     prefix : config.prefix
   })
@@ -57,11 +73,22 @@ function encode_p2wpkh_address (
 
 function decode_p2wpkh_address (
   address : string
-) : AddressData {
+) : AddressInfo {
   // Parse the address.
-  const parsed = parse_address(address)
+  const parsed = get_address_info(address)
   // Assert the address type is correct.
-  Assert.ok(parsed.type === 'p2w-pkh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE}`)
+  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,53 +1,69 @@
-import { Buff }           from '@vbyte/buff'
-import { Assert }         from '@vbyte/micro-lib'
-import { sha256 }         from '@vbyte/micro-lib/hash'
-import { encode_address } from './encode.js'
+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,
-  parse_address
+  get_address_info
 } from './util.js'
 
 import type {
-  ChainNetwork,
-  AddressData
+  AddressInfo,
+  ChainNetwork
 } from '@/types/index.js'
 
-const ADDR_TYPE = 'p2w-sh'
+const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2WSH
 
 export namespace P2WSH {
-  export const create = create_p2wsh_address
-  export const encode = encode_p2wsh_address
-  export const decode = decode_p2wsh_address
+  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  : string | Uint8Array,
+  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)
-  // Encode the address.
-  return encode_p2wsh_address(hash, network)
+  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_hash : string | Uint8Array,
-  network     : ChainNetwork = 'main',
+  script_pk : Bytes,
+  network   : ChainNetwork = 'main',
 ) : string {
-  // Convert the script hash into bytes.
-  const bytes  = Buff.bytes(script_hash)
+  // 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, ADDR_TYPE)
+  const config = get_address_config(network, ADDRESS_TYPE)
   // Assert the configuration exists.
-  Assert.exists(config, `unrecognized address config: ${ADDR_TYPE} on ${network}` )
+  Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE} on ${network}` )
   // Assert the payload size is correct.
-  Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}` )
+  Assert.size(script_hash, config.size, `invalid payload size: ${script_hash.length} !== ${config.size}` )
   // Encode the address.
   return encode_address({
-    data   : bytes,
+    data   : script_hash,
     format : 'bech32',
     prefix : config.prefix
   })
@@ -55,11 +71,22 @@ function encode_p2wsh_address (
 
 function decode_p2wsh_address (
   address : string
-) : AddressData {
+) : AddressInfo {
   // Parse the address.
-  const parsed = parse_address(address)
+  const parsed = get_address_info(address)
   // Assert the address type is correct.
-  Assert.ok(parsed.type === 'p2w-sh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE}`)
+  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,4 +1,4 @@
-import type { AddressType } from '@/types/index.js'
+import type { AddressType, ScriptInfo } from '@/types/index.js'
 
 /**
  * Get the address script.
@@ -10,15 +10,15 @@ import type { AddressType } from '@/types/index.js'
 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 'p2w-pkh':
+    case 'p2wpkh':
       return get_p2w_pkh_script(script_key)
-    case 'p2w-sh':
+    case 'p2wsh':
       return get_p2w_sh_script(script_key)
     case 'p2tr':
       return get_p2tr_script(script_key)
@@ -29,35 +29,35 @@ export function get_address_script (
 
 function get_p2pkh_script (script_key : string) {
   return {
-    script_hex : '76a914' + script_key + '88ac',
-    script_asm : [ 'OP_DUP', 'OP_HASH160', script_key, 'OP_EQUALVERIFY', 'OP_CHECKSIG' ]
+    hex : '76a914' + script_key + '88ac',
+    asm : [ 'OP_DUP', 'OP_HASH160', script_key, 'OP_EQUALVERIFY', 'OP_CHECKSIG' ]
   }
 }
 
 function get_p2sh_script (script_key : string) {
   return {
-    script_hex : 'a914' + script_key + '87',
-    script_asm : [ 'OP_HASH160', script_key, 'OP_EQUAL' ]
+    hex : 'a914' + script_key + '87',
+    asm : [ 'OP_HASH160', script_key, 'OP_EQUAL' ]
   }
 }
 
 function get_p2w_pkh_script (script_key : string) {
   return {
-    script_hex : '0014' + script_key,
-    script_asm : [ 'OP_0', script_key ]
+    hex : '0014' + script_key,
+    asm : [ 'OP_0', script_key ]
   }
 }
 
 function get_p2w_sh_script (script_key : string) {
   return {
-    script_hex : '0020' + script_key,
-    script_asm : [ 'OP_0', script_key ]
+    hex : '0020' + script_key,
+    asm : [ 'OP_0', script_key ]
   }
 }
 
 function get_p2tr_script (script_key : string) {
   return {
-    script_hex : '5120' + script_key,
-    script_asm : [ 'OP_1', script_key ]
+    hex : '5120' + script_key,
+    asm : [ 'OP_1', script_key ]
   }
 }

package/src/lib/address/util.ts

@@ -5,10 +5,9 @@ import { get_address_script } from './script.js'
 import type {
   AddressConfig,
   AddressConfigEntry,
-  AddressType,
+  AddressInfo,
   ChainNetwork,
-  AddressContext,
-  AddressData
+  LockScriptType,
 } from '@/types/index.js'
 
 const CONFIG_TABLE : AddressConfigEntry[] = [
@@ -20,12 +19,12 @@ const CONFIG_TABLE : AddressConfigEntry[] = [
   [ 'm',      'p2pkh',   'regtest', 20, 'base58',  0x6F ],
   [ 'n',      'p2pkh',   'regtest', 20, 'base58',  0x6F ],
   [ '2',      'p2sh',    'regtest', 20, 'base58',  0xC4 ],
-  [ 'bc',     'p2w-pkh', 'main',    20, 'bech32',  0    ],
-  [ 'tb',     'p2w-pkh', 'testnet', 20, 'bech32',  0    ],
-  [ 'bcrt',   'p2w-pkh', 'regtest', 20, 'bech32',  0    ],
-  [ 'bc',     'p2w-sh',  'main',    32, 'bech32',  0    ],
-  [ 'tb',     'p2w-sh',  'testnet', 32, 'bech32',  0    ],
-  [ 'bcrt',   'p2w-sh',  'regtest', 32, 'bech32',  0    ],
+  [ '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    ]
@@ -40,7 +39,7 @@ const CONFIG_TABLE : AddressConfigEntry[] = [
  */
 export function get_address_config (
   address_network : ChainNetwork,
-  address_type    : AddressType
+  address_type    : LockScriptType
 ) : AddressConfig | null {
   // For each configuration in the table,
   for (const [ prefix, type, network, size, format, version ] of CONFIG_TABLE) {
@@ -55,12 +54,12 @@ export function get_address_config (
 }
 
 /**
- * Get the address context.
+ * Parse an address into its data and script.
  * 
- * @param address - The address to get the context for.
- * @returns The address context.
+ * @param address - The address to parse.
+ * @returns The address data and script.
  */
-export function get_address_ctx (address : string) : AddressContext {
+export function get_address_info (address : string) : AddressInfo {
   // Decode the address.
   const dec = decode_address(address)
   // For each configuration in the table,
@@ -78,25 +77,11 @@ export function get_address_ctx (address : string) : AddressContext {
     }
 
     // Convert the decoded data into a hex string.
-    const hex = Buff.uint(dec.data).hex
+    const data   = Buff.uint(dec.data).hex
+    const script = get_address_script(data, type)
     // Return the address configuration and data.
-    return { data: dec.data, hex, type, prefix, network, size, format, version }
+    return { data, script,type, prefix, network, size, format, version }
   }
   // Otherwise, throw an error
   throw new Error('address configuration is invalid')
 }
-
-/**
- * Parse an address into its data and script.
- * 
- * @param address - The address to parse.
- * @returns The address data and script.
- */
-export function parse_address (address : string) : AddressData {
-  // Get the address context.
-  const ctx    = get_address_ctx(address)
-  // Get the address script.
-  const script = get_address_script(ctx.hex, ctx.type)
-  // Return the address data.
-  return { ...ctx, ...script }
-}

package/src/lib/script/decode.ts

@@ -1,4 +1,4 @@
-import { Bytes, Stream } from '@vbyte/buff'
+import { Buff, Bytes, Stream } from '@vbyte/buff'
 
 import {
   get_op_code,
@@ -6,6 +6,16 @@ import {
   is_valid_op
 } from './words.js'
 
+import type { ScriptInfo } from '@/types/script.js'
+
+export function parse_script (script: Bytes): ScriptInfo {
+  const bytes = Buff.bytes(script)
+  return {
+    asm: decode_script(bytes),
+    hex: bytes.hex
+  }
+}
+
 /**
  * Decode a bitcoin script into asm instructions.
  */

package/src/lib/script/index.ts

@@ -1,26 +1,20 @@
-import { OPCODE_MAP }    from './words.js'
 import { encode_script } from './encode.js'
 
 import {
   decode_script,
-  is_valid_script
+  is_valid_script,
+  parse_script
 } from './decode.js'
 
-import {
-  parse_script_pubkeys,
-  prefix_script_size
-} from './util.js'
-
 export * from './decode.js'
 export * from './encode.js'
+export * from './lock.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
+  export const parse    = parse_script
+  export const decode   = decode_script
+  export const encode   = encode_script
+  export const is_valid = is_valid_script
 }

package/src/lib/script/lock.ts

@@ -0,0 +1,73 @@
+import { Buff, Bytes }       from '@vbyte/buff'
+import { LOCK_SCRIPT_REGEX } from '@/const.js'
+
+import type {
+  LockScriptInfo,
+  LockScriptType,
+  WitnessVersion
+} from '@/types/index.js'
+
+export function is_return_script (script : Bytes) : boolean {
+  const bytes = Buff.bytes(script)
+  return bytes.at(0) === 0x6a
+}
+
+export function get_lock_script_info (script : Bytes) : LockScriptInfo {
+  return {
+    type    : get_lock_script_type(script),
+    version : get_lock_script_version(script)
+  }
+}
+
+export function get_lock_script_type (script : Bytes) : LockScriptType | null {
+  // Get the hex string of the script.
+  const hex = Buff.bytes(script).hex
+  // Iterate over the lock script regexes.
+  for (const [ type, regex ] of Object.entries(LOCK_SCRIPT_REGEX)) {
+    // If the script matches the regex, return the type.
+    if (regex.test(hex)) return type as LockScriptType
+  }
+  // If the script does not match any regex, return null.
+  return null
+}
+
+export function get_lock_script_version (script : Bytes) : WitnessVersion | null {
+  // Get the version of the script.
+  const version = Buff.bytes(script)
+  // Return the version of the script.
+  switch (version.at(0)) {
+    case 0x00 : return 0
+    case 0x51 : return 1
+    default   : return null
+  }
+}
+
+export function is_p2pkh_script (script : Bytes) : boolean {
+  const hex = Buff.bytes(script).hex
+  return LOCK_SCRIPT_REGEX['p2pkh'].test(hex)
+}
+
+export function is_p2sh_script (script : Bytes) : boolean {
+  const hex = Buff.bytes(script).hex
+  return LOCK_SCRIPT_REGEX['p2sh'].test(hex)
+}
+
+export function is_p2wpkh_script (script : Bytes) : boolean {
+  const hex = Buff.bytes(script).hex
+  return LOCK_SCRIPT_REGEX['p2wpkh'].test(hex)
+}
+
+export function is_p2wsh_script (script : Bytes) : boolean {
+  const hex = Buff.bytes(script).hex
+  return LOCK_SCRIPT_REGEX['p2wsh'].test(hex)
+}
+
+export function is_p2tr_script (script : Bytes) : boolean {
+  const hex = Buff.bytes(script).hex
+  return LOCK_SCRIPT_REGEX['p2tr'].test(hex)
+}
+
+export function is_opreturn_script (script : Bytes) : boolean {
+  const hex = Buff.bytes(script).hex
+  return LOCK_SCRIPT_REGEX['opreturn'].test(hex)
+}