@vbyte/btc-dev 1.1.3 → 1.1.5

package/dist/types/address.d.ts

@@ -1,7 +1,7 @@
+import type { ScriptInfo } from './script.js';
 export type AddressFormat = 'base58' | 'bech32' | 'bech32m';
-export type AddressType = 'p2pkh' | 'p2sh' | 'p2w-pkh' | 'p2w-sh' | 'p2tr';
+export type AddressType = 'p2pkh' | 'p2sh' | 'p2wpkh' | 'p2wsh' | 'p2tr';
 export type ChainNetwork = 'main' | 'testnet' | 'regtest' | string;
-export type AddressData = AddressContext & ScriptData;
 export type AddressConfigEntry = [
     prefix: string,
     type: AddressType,
@@ -10,7 +10,7 @@ export type AddressConfigEntry = [
     format: AddressFormat,
     version: number
 ];
-export interface DecodedAddress {
+export interface EncoderConfig {
     format: AddressFormat;
     data: Uint8Array;
     prefix?: string;
@@ -24,11 +24,7 @@ export interface AddressConfig {
     type: AddressType;
     version: number;
 }
-export interface AddressContext extends AddressConfig {
-    data: Uint8Array;
-    hex: string;
-}
-export interface ScriptData {
-    script_asm: string[];
-    script_hex: string;
+export interface AddressInfo extends AddressConfig {
+    data: string;
+    script: ScriptInfo;
 }

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
 export * from './address.js';
 export * from './meta.js';
 export * from './psbt.js';
+export * from './script.js';
 export * from './sighash.js';
 export * from './taproot.js';
 export * from './txdata.js';

package/dist/types/index.js

@@ -1,6 +1,7 @@
 export * from './address.js';
 export * from './meta.js';
 export * from './psbt.js';
+export * from './script.js';
 export * from './sighash.js';
 export * from './taproot.js';
 export * from './txdata.js';

package/dist/types/meta.d.ts

@@ -1,16 +1,6 @@
-import type { WitnessType, WitnessVersion } from './witness.js';
 export type LocktimeData = LocktimeStamp | LocktimeHeight;
 export type SequenceConfig = Partial<SequenceData>;
 export type SequenceData = SequenceHeightLock | SequenceStampLock;
-export type TxOutputType = 'p2pkh' | 'p2sh' | 'p2w-pkh' | 'p2w-sh' | 'p2tr' | 'opreturn';
-export interface TxOutputInfo {
-    type: TxOutputType | null;
-    version: WitnessVersion | null;
-}
-export interface TxInputInfo {
-    type: WitnessType;
-    version: WitnessVersion;
-}
 export interface LocktimeStamp {
     type: 'timelock';
     stamp: number;
@@ -37,10 +27,6 @@ export interface SequenceField {
     data: SequenceData | null;
     value: number;
 }
-export interface ScriptField {
-    asm: string[];
-    hex: string;
-}
 export interface InscriptionData {
     content?: string;
     delegate?: string;

package/dist/types/script.d.ts

@@ -0,0 +1,15 @@
+export type LockScriptType = 'p2pkh' | 'p2sh' | 'p2wpkh' | 'p2wsh' | 'p2tr' | 'opreturn';
+export type SpendScriptType = 'p2pkh' | 'p2sh' | 'p2wpkh' | 'p2wsh' | 'p2tr' | 'p2ts';
+export type WitnessVersion = 0 | 1 | null;
+export interface ScriptInfo {
+    asm: string[];
+    hex: string;
+}
+export interface LockScriptInfo {
+    type: LockScriptType | null;
+    version: WitnessVersion | null;
+}
+export interface SpendScriptInfo {
+    type: SpendScriptType;
+    version: WitnessVersion;
+}

package/dist/types/script.js

@@ -0,0 +1 @@
+export {};

package/dist/types/witness.d.ts

@@ -1,6 +1,5 @@
+import type { SpendScriptType, WitnessVersion } from './script.js';
 export type WitnessContext = WitnessData | TaprootScript | SegwitScript | TaprootSpend | SegwitSpend;
-export type WitnessVersion = number | null;
-export type WitnessType = 'p2w-pkh' | 'p2w-sh' | 'p2tr-pk' | 'p2tr-ts' | 'unknown';
 export interface WitnessSize {
     total: number;
     vsize: number;
@@ -11,25 +10,25 @@ export interface WitnessData {
     params: string[];
     script: string | null;
     stack: string[];
-    type: WitnessType;
-    version: WitnessVersion;
+    type: SpendScriptType | null;
+    version: WitnessVersion | null;
 }
 export interface TaprootScript extends WitnessData {
     cblock: string;
     script: string;
-    type: 'p2tr-ts';
+    type: 'p2ts';
     version: 1;
 }
 export interface SegwitScript extends WitnessData {
     script: string;
-    type: 'p2w-sh';
+    type: 'p2wsh';
     version: 0;
 }
 export interface TaprootSpend extends WitnessData {
-    type: 'p2tr-pk';
+    type: 'p2tr';
     version: 1;
 }
 export interface SegwitSpend extends WitnessData {
-    type: 'p2w-pkh';
+    type: 'p2wpkh';
     version: 0;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vbyte/btc-dev",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Batteries-included toolset for plebian bitcoin development",
   "type": "module",
   "keywords": [

package/src/const.ts

@@ -20,14 +20,32 @@ export const TAPLEAF_VERSIONS = [
 
 export const TAPLEAF_DEFAULT_VERSION = 0xc0
 
+export const LOCK_SCRIPT_TYPE = {
+  P2PKH    : 'p2pkh',
+  P2SH     : 'p2sh',
+  P2WPKH   : 'p2wpkh',
+  P2WSH    : 'p2wsh',
+  P2TR     : 'p2tr',
+  OPRETURN : 'opreturn',
+} as const
+
+export const SPEND_SCRIPT_TYPE = {
+  P2PKH    : 'p2pkh',
+  P2SH     : 'p2sh',
+  P2WPKH   : 'p2wpkh',
+  P2WSH    : 'p2wsh',
+  P2TR     : 'p2tr',
+  P2TS     : 'p2ts',
+} as const
+
 export const LOCK_SCRIPT_REGEX : Record<string, RegExp> = {
-  'p2pkh'    : /^76a914[0-9a-f]{40}88ac$/i,
-  'p2sh'     : /^a914[0-9a-f]{40}87$/i,
-  'p2wpkh'   : /^0014[0-9a-f]{40}$/i,
-  'p2wsh'    : /^0020[0-9a-f]{64}$/i,
-  'p2tr'     : /^5120[0-9a-f]{64}$/i,
-  'opreturn' : /^6a[0-9a-f]{2,}$/i,
-}
+  [LOCK_SCRIPT_TYPE.P2PKH]    : /^76a914[0-9a-f]{40}88ac$/i,
+  [LOCK_SCRIPT_TYPE.P2SH]     : /^a914[0-9a-f]{40}87$/i,
+  [LOCK_SCRIPT_TYPE.P2WPKH]   : /^0014[0-9a-f]{40}$/i,
+  [LOCK_SCRIPT_TYPE.P2WSH]    : /^0020[0-9a-f]{64}$/i,
+  [LOCK_SCRIPT_TYPE.P2TR]     : /^5120[0-9a-f]{64}$/i,
+  [LOCK_SCRIPT_TYPE.OPRETURN] : /^6a[0-9a-f]{2,}$/i,
+} as const
 
 export const SCRIPT_INT_KEY = ''
 

package/src/lib/address/api.ts

@@ -0,0 +1,50 @@
+import { Buff, Bytes }          from '@vbyte/buff'
+import { get_lock_script_type } from '@/lib/script/lock.js'
+import { get_address_info }     from './util.js'
+import { LOCK_SCRIPT_TYPE }     from '@/const.js'
+
+import { P2PKH }  from './p2pkh.js'
+import { P2SH }   from './p2sh.js'
+import { P2TR }   from './p2tr.js'
+import { P2WPKH } from './p2wpkh.js'
+import { P2WSH }  from './p2wsh.js'
+
+import type { AddressInfo, ChainNetwork } from '@/types/index.js'
+
+/**
+ * Parse an address into its data and script.
+ * 
+ * @param address - The address to parse.
+ * @returns The address data and script.
+ */
+export function create_address (
+  script  : Bytes,
+  network : ChainNetwork = 'main'
+) : string {
+  // Convert the script into bytes.
+  const bytes = Buff.bytes(script)
+  // Get the address configuration.
+  const type = get_lock_script_type(bytes)
+  // If the script type is not recognized, throw an error.
+  if (type === null) throw new Error('unrecognized script type: ' + bytes.hex)
+  // Create the address based on the script type.
+  switch (type) {
+    case LOCK_SCRIPT_TYPE.P2PKH:
+      return P2PKH.create_address(script, network)
+    case LOCK_SCRIPT_TYPE.P2SH:
+      return P2SH.create_address(script, network)
+    case LOCK_SCRIPT_TYPE.P2WPKH:
+      return P2WPKH.create_address(script, network)
+    case LOCK_SCRIPT_TYPE.P2WSH:
+      return P2WSH.create_address(script, network)
+    case LOCK_SCRIPT_TYPE.P2TR:
+      return P2TR.create_address(script, network)
+    default:
+      // If the script type is not recognized, throw an error.
+      throw new Error('unrecognized script type: ' + type)
+  }
+}
+
+export function parse_address (address : string) : AddressInfo {
+  return get_address_info(address)
+}

package/src/lib/address/encode.ts

@@ -4,7 +4,7 @@ import { Assert, B58chk, Bech32, Bech32m } from '@vbyte/micro-lib'
 
 import type {
   AddressFormat,
-  DecodedAddress,
+  EncoderConfig,
 } from '@/types/address.js'
 
 const ENCODING_REGEX = {
@@ -24,7 +24,7 @@ const VERSION = {
  * @param address - The address to decode.
  * @returns The decoded address.
  */
-export function decode_address (address : string) : DecodedAddress {
+export function decode_address (address : string) : EncoderConfig {
   // Get the address format.
   const format = get_address_format(address)
   // If the format is not found, throw an error.
@@ -45,7 +45,7 @@ export function decode_address (address : string) : DecodedAddress {
  *          recognized.
  */
 export function encode_address (
-  config : DecodedAddress
+  config : EncoderConfig
 ) : string {
   // Encode the address based on the format.
   if (config.format === 'base58')  return base58_encode(config)
@@ -78,7 +78,7 @@ function get_address_format (address : string) : AddressFormat | null {
  * @param config - The encoder configuration.
  * @returns The encoded base58 string.
  */
-function base58_encode (config : DecodedAddress) : string {
+function base58_encode (config : EncoderConfig) : string {
   // Assert the format is correct.
   Assert.ok(config.format === 'base58', 'encoding mismatch')
   // Assert the version is specified.
@@ -95,7 +95,7 @@ function base58_encode (config : DecodedAddress) : string {
  * @param encoded - The base58 string to decode.
  * @returns The decoded data.
  */
-function base58_decode (encoded : string) : DecodedAddress {
+function base58_decode (encoded : string) : EncoderConfig {
   // Decode the encoded data.
   const bytes = B58chk.decode(encoded)
   // Get the data from the decoded bytes.
@@ -112,7 +112,7 @@ function base58_decode (encoded : string) : DecodedAddress {
  * @param config - The encoder configuration.
  * @returns The encoded bech32 string.
  */
-function bech32_encode (config : DecodedAddress) : string {
+function bech32_encode (config : EncoderConfig) : string {
   // Assert the format is correct.
   Assert.ok(config.format === 'bech32', 'encoding mismatch')
   // Assert the prefix is specified.
@@ -131,7 +131,7 @@ function bech32_encode (config : DecodedAddress) : string {
  * @param encoded - The bech32 string to decode.
  * @returns The decoded data.
  */
-function bech32_decode (encoded : string) : DecodedAddress {
+function bech32_decode (encoded : string) : EncoderConfig {
   // Decode the encoded data.
   const { prefix, words } = Bech32.decode(encoded)
   // Get the version and rest of the words.
@@ -150,7 +150,7 @@ function bech32_decode (encoded : string) : DecodedAddress {
  * @param config - The encoder configuration.
  * @returns The encoded bech32 string.
  */
-function bech32m_encode (config : DecodedAddress) : string {
+function bech32m_encode (config : EncoderConfig) : string {
   // Assert the format is correct.
   Assert.ok(config.format === 'bech32m', 'encoding mismatch')
   // Assert the prefix is specified.
@@ -169,7 +169,7 @@ function bech32m_encode (config : DecodedAddress) : string {
  * @param encoded - The bech32 string to decode.
  * @returns The decoded data.
  */
-function bech32m_decode (encoded : string) : DecodedAddress {
+function bech32m_decode (encoded : string) : EncoderConfig {
   // Decode the encoded data.
   const { prefix, words }    = Bech32m.decode(encoded)
   // Get the version and rest of the words.

package/src/lib/address/index.ts

@@ -1,24 +1,7 @@
-import { P2PKH  as P2PKH_TOOL  } from './p2pkh.js'
-import { P2SH   as P2SH_TOOL   } from './p2sh.js'
-import { P2WPKH as P2WPKH_TOOL } from './p2wpkh.js'
-import { P2WSH  as P2WSH_TOOL  } from './p2wsh.js'
-import { P2TR   as P2TR_TOOL   } from './p2tr.js'
-
-import { parse_address } from './util.js'
-
 export { P2PKH }  from './p2pkh.js'
 export { P2SH }   from './p2sh.js'
 export { P2WPKH } from './p2wpkh.js'
 export { P2WSH }  from './p2wsh.js'
 export { P2TR }   from './p2tr.js'
 
-export { parse_address } from './util.js'
-
-export namespace AddressTool {
-  export const P2PKH   = P2PKH_TOOL
-  export const P2SH    = P2SH_TOOL
-  export const P2WPKH  = P2WPKH_TOOL
-  export const P2WSH   = P2WSH_TOOL
-  export const P2TR    = P2TR_TOOL
-  export const parse   = parse_address
-}
+export * from './api.js'

package/src/lib/address/p2pkh.ts

@@ -1,53 +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_p2pkh_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 = 'p2pkh'
+const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2PKH
 
 export namespace P2PKH {
-  export const create = create_p2pkh_address
-  export const encode = encode_p2pkh_address
-  export const decode = decode_p2pkh_address
+  export const create_address = create_p2pkh_address
+  export const create_script  = create_p2pkh_script
+  export const encode_address = encode_p2pkh_address
+  export const encode_script  = encode_p2pkh_script
+  export const decode_address = decode_p2pkh_address
+  export const decode_script  = decode_p2pkh_script
 }
 
 function create_p2pkh_address (
-  script  : string | Uint8Array,
+  pubkey  : Bytes,
   network : ChainNetwork = 'main',
 ) : string {
-  // Convert the script into bytes.
-  const bytes = Buff.bytes(script)
+  // Create the p2pkh script.
+  const script = create_p2pkh_script(pubkey)
+  // Encode the script as an address.
+  return encode_p2pkh_address(script, network)
+}
+
+function create_p2pkh_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)
-  // Encode the hash as an address.
-  return encode_p2pkh_address(hash, network)
+  // Return the script.
+  return encode_p2pkh_script(hash)
+}
+
+function encode_p2pkh_script (pk_hash : Bytes) : Buff {
+  return Buff.join([ '76a914', pk_hash, '88ac' ])
 }
 
 function encode_p2pkh_address (
-  pk_hash : string | Uint8Array,
+  script  : 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_p2pkh_script(script)
   // 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  : 'base58',
     version : config.version
   })
@@ -55,11 +73,22 @@ function encode_p2pkh_address (
 
 function decode_p2pkh_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 === 'p2pkh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE}`)
+  Assert.ok(parsed.type === 'p2pkh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`)
   // Return the parsed address.
   return parsed
 }
+
+function decode_p2pkh_script (
+  script  : Bytes,
+) : Buff {
+  // Convert the script into bytes.
+  const bytes = Buff.bytes(script)
+  // Assert the script is a p2pkh script.
+  Assert.ok(is_p2pkh_script(script), `invalid p2pkh script`)
+  // Return the public key hash from the script.
+  return bytes.slice(3, 23)
+}

package/src/lib/address/p2sh.ts

@@ -1,53 +1,73 @@
-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_p2sh_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 = 'p2sh'
+const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2SH
 
 export namespace P2SH {
-  export const create = create_p2sh_address
-  export const encode = encode_p2sh_address
-  export const decode = decode_p2sh_address
+  export const create_address = create_p2sh_address
+  export const create_script  = create_p2sh_script
+  export const encode_address = encode_p2sh_address
+  export const encode_script  = encode_p2sh_script
+  export const decode_address = decode_p2sh_address
+  export const decode_script  = decode_p2sh_script
 }
 
 function create_p2sh_address (
-  script  : string | Uint8Array,
+  script  : Bytes,
   network : ChainNetwork = 'main',
 ) : string {
   // Convert the script into bytes.
   const bytes = Buff.bytes(script)
   // Convert the bytes into a hash.
   const hash = hash160(bytes)
+  // Create the p2sh script.
+  const p2sh_script = encode_p2sh_script(hash)
   // Encode the address.
-  return encode_p2sh_address(hash, network)
+  return encode_p2sh_address(p2sh_script, network)
+}
+
+function create_p2sh_script (script : Bytes) : Buff {
+  // Convert the script into bytes.
+  const bytes = Buff.bytes(script)
+  // Convert the bytes into a hash.
+  const hash = hash160(bytes)
+  // Return the script.
+  return encode_p2sh_script(hash)
+}
+
+function encode_p2sh_script (script_hash : Bytes) : Buff {
+  return Buff.join([ 'a914', script_hash, '87' ])
 }
 
 function encode_p2sh_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_p2sh_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  : 'base58',
     version : config.version
   })
@@ -55,11 +75,22 @@ function encode_p2sh_address (
 
 function decode_p2sh_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 === 'p2sh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE}`)
+  Assert.ok(parsed.type === 'p2sh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`)
   // Return the parsed address.
   return parsed
 }
+
+function decode_p2sh_script (
+  script  : Bytes,
+) : Buff {
+  // Assert the script is a p2sh script.
+  Assert.ok(is_p2sh_script(script), `invalid p2sh script`)
+  // Convert the script into bytes.
+  const bytes = Buff.bytes(script)
+  // Return the script hash from the script.
+  return bytes.slice(2, 22)
+}