@vbyte/btc-dev 1.1.8 → 2.0.0

package/CHANGELOG.md

@@ -0,0 +1,94 @@
+# CHANGELOG
+
+## [2.0.0] - 2026-01-23
+
+### Security Fixes
+
+- **Fixed witness parsing bug**: Added missing `break` statements in switch block in `src/lib/witness/parse.ts` that could cause incorrect script extraction for p2ts and p2wsh witness types.
+- **Implemented `verify_tx()` function**: Full signature verification for segwit (ECDSA) and taproot (Schnorr) transactions, supporting all sighash types.
+- **Added input validation to sign functions**: Secret key format validation in `sign_segwit_tx()` and `sign_taproot_tx()` to prevent invalid key errors.
+- **Added transaction size limits**: Maximum transaction size (4MB), varint size (10MB), and element count (100k) limits in decoder to prevent memory exhaustion attacks.
+- **Added taproot tree depth limits**: Maximum depth of 128 levels in merkle tree construction to prevent stack overflow from deeply nested trees.
+- **Sanitized error messages**: Removed sensitive data from error messages in address and transaction modules.
+- **Fixed taproot verification null check**: Added proper null check for `prevout` in taproot input verification to prevent runtime errors.
+
+### New Features
+
+- **Full signature verification**: `verify_tx()` now returns detailed verification results including per-input status and error messages.
+- **Enhanced witness parsing**: Improved annex detection and control block parsing for taproot witnesses.
+
+### Code Quality
+
+- **Biome linting compliance**: Applied comprehensive linting fixes across all 59 source files in `src/`
+  - Converted string concatenation to template literals
+  - Added explicit radix parameter to all `parseInt()` calls
+  - Converted `import` statements to `import type` where appropriate
+  - Replaced `isNaN()` with `Number.isNaN()` for type safety
+  - Simplified computed property access to literal keys
+  - Standardized code formatting (quotes, semicolons, indentation)
+- **Improved control block construction**: Replaced `forEach` with spread operator in taproot control block building
+
+### Testing
+
+- Added 843+ new tests (total: 1063 tests passing)
+- **SIGNER module tests**: Essential signing function tests, transaction scenarios, and sighash coverage
+- **WITNESS module tests**: Full witness parsing coverage (p2wpkh, p2wsh, p2tr, p2ts, annex) plus edge cases
+- **SCRIPT module tests**: Lock script detection, decode/encode roundtrips, malformed script handling, size limits
+- **SIGHASH module tests**: Bounds checking and edge cases
+- **META module tests**: BIP-65 locktime, BIP-68 sequence, and reference pointer encoding/decoding
+- **TX module tests**: Size calculation, essential operations, create functions, encoding functions, error handling
+- **TAPROOT module tests**: Parse operations coverage
+- **Integration tests**: End-to-end workflows for address creation, transaction building, and signing
+
+### Documentation
+
+- **README.md**: Expanded with installation instructions, quick start guide, module overview, and API examples
+- **SECURITY.md**: New security guidelines document covering private key handling, input validation, and best practices
+- **EXAMPLES.md**: New examples document with practical code for common Bitcoin development tasks
+- **CONVENTIONS.md**: Added project coding conventions documentation
+- **JSDoc**: Added comprehensive documentation to exported functions with @param, @returns, @throws, and @example
+- **Type definitions**: Documented all interfaces in `src/types/`
+- **Schemas**: Added inline documentation for validation schemas
+
+### Breaking Changes
+
+- `verify_tx()` now returns a `VerifyResult` object instead of a boolean. Access the `.valid` property for boolean result.
+
+## [1.1.8]
+
+- Removed excess logging.
+
+## [1.1.7]
+
+- Removed schema dependency.
+- Fixed an issue with the transaction encoder.
+
+## [1.1.6]
+
+- Changed `create_address` to `get_address`, fixed issues with interface.
+
+## [1.1.5]
+
+- Updated exports for Script module.
+
+## [1.1.4]
+
+- Updates to API for Address module.
+- Updates to API for Script module.
+- Updates to API for TX module.
+
+## [1.1.3]
+
+- Updated transaction utils to have a better input interface.
+
+## [1.1.2]
+
+- Methods `get_tx_output_type` and `get_tx_output_version` have been updated and replaced with `get_script_pk_type` and `get_script_pk_version`.
+
+## [1.1.1]
+
+- Updated `encode_script`
+
+## [1.1.0]
+
+- Public release.

package/README.md

@@ -1,5 +1,262 @@
-# btc-dev
+# @vbyte/btc-dev
 
-Experimental revision of the bitcoin [tapscript](https://www.npmjs.com/package/@cmdcode/tapscript) library.
+A batteries-included TypeScript toolset for Bitcoin development. Create, sign, and verify Bitcoin transactions with full support for segwit and taproot.
 
-Documentation coming soon!
+## Features
+
+- **Full Address Support**: P2PKH, P2SH, P2WPKH, P2WSH, P2TR (taproot)
+- **Transaction Building**: Create, encode, decode, and parse Bitcoin transactions
+- **Signature Hashing**: BIP-143 (segwit) and BIP-341 (taproot) sighash calculation
+- **Signing & Verification**: ECDSA (segwit) and Schnorr (taproot) signatures
+- **Taproot Scripts**: Merkle tree construction, control blocks, and script-path spends
+- **Script Handling**: Encode/decode Bitcoin scripts, lock script detection
+- **Metadata Utilities**: Locktime, sequence (BIP-68), outpoints, rune IDs, inscription IDs
+- **Type Safety**: Full TypeScript support with strict types
+- **Tree-shakeable**: Import only what you need
+
+## Installation
+
+```bash
+npm install @vbyte/btc-dev
+```
+
+## Quick Start
+
+```typescript
+import { ADDRESS, TX, SIGNER } from '@vbyte/btc-dev'
+
+// Create a P2WPKH address from a public key
+const address = ADDRESS.p2wpkh(pubkey, 'main')
+console.log(address.data)  // bc1q...
+
+// Parse a raw transaction
+const tx = TX.parse(txhex)
+console.log(tx.vin.length, 'inputs')
+console.log(tx.vout.length, 'outputs')
+
+// Sign a segwit transaction
+const signature = SIGNER.sign_segwit_tx(secretKey, txdata, {
+  txindex: 0,
+  pubkey: publicKey,
+  sigflag: 0x01  // SIGHASH_ALL
+})
+```
+
+## Module Overview
+
+| Module | Description |
+|--------|-------------|
+| `ADDRESS` | Create and parse Bitcoin addresses (P2PKH, P2SH, P2WPKH, P2WSH, P2TR) |
+| `TX` | Transaction creation, encoding, decoding, parsing, and validation |
+| `SCRIPT` | Bitcoin script encoding, decoding, and lock script detection |
+| `SIGHASH` | Signature hash calculation for segwit (BIP-143) and taproot (BIP-341) |
+| `SIGNER` | Sign and verify transactions using ECDSA and Schnorr |
+| `TAPROOT` | Taproot tree construction, control blocks, and tweaking |
+| `WITNESS` | Parse and analyze witness data |
+| `META` | Locktime, sequence, outpoints, and reference IDs |
+
+## Import Patterns
+
+```typescript
+// Import all namespaces
+import { ADDRESS, TX, SCRIPT, SIGHASH, SIGNER, TAPROOT, WITNESS, META } from '@vbyte/btc-dev'
+
+// Tree-shaking: import specific modules
+import { p2wpkh, p2tr } from '@vbyte/btc-dev/address'
+import { parse_tx, encode_tx } from '@vbyte/btc-dev/tx'
+import { sign_segwit_tx, sign_taproot_tx, verify_tx } from '@vbyte/btc-dev/signer'
+```
+
+## API Highlights
+
+### Address Creation
+
+```typescript
+import { ADDRESS } from '@vbyte/btc-dev'
+
+// P2PKH (legacy)
+const p2pkh = ADDRESS.p2pkh(pubkey, 'main')
+
+// P2WPKH (native segwit)
+const p2wpkh = ADDRESS.p2wpkh(pubkey, 'main')
+
+// P2WSH (segwit script hash)
+const p2wsh = ADDRESS.p2wsh(redeemScript, 'main')
+
+// P2TR (taproot)
+const p2tr = ADDRESS.p2tr(xOnlyPubkey, 'main')
+```
+
+### Transaction Parsing
+
+```typescript
+import { TX } from '@vbyte/btc-dev'
+
+// Parse raw transaction hex
+const tx = TX.parse(rawTxHex)
+
+// Access transaction data
+console.log(tx.version)      // Transaction version
+console.log(tx.vin)          // Inputs array
+console.log(tx.vout)         // Outputs array
+console.log(tx.locktime)     // Locktime
+
+// Encode transaction back to hex
+const encoded = TX.encode(tx)
+```
+
+### Signing Transactions
+
+```typescript
+import { SIGNER } from '@vbyte/btc-dev'
+
+// Sign segwit (v0) transaction input
+const segwitSig = SIGNER.sign_segwit_tx(secretKey, txdata, {
+  txindex: 0,           // Input index to sign
+  pubkey: compressedPubkey,  // For P2WPKH
+  sigflag: 0x01         // SIGHASH_ALL
+})
+
+// Sign taproot (v1) transaction input
+const taprootSig = SIGNER.sign_taproot_tx(secretKey, txdata, {
+  txindex: 0,
+  sigflag: 0x00         // SIGHASH_DEFAULT (taproot)
+})
+
+// Verify all signatures in a transaction
+const result = SIGNER.verify_tx(txdata)
+if (result.valid) {
+  console.log('All signatures valid')
+} else {
+  console.log('Verification failed:', result.error)
+  result.inputs.forEach(input => {
+    if (!input.valid) console.log(`Input ${input.index}: ${input.error}`)
+  })
+}
+```
+
+### Taproot Scripts
+
+```typescript
+import { TAPROOT } from '@vbyte/btc-dev'
+
+// Create a taproot output with scripts
+const taprootCtx = TAPROOT.create({
+  pubkey: internalPubkey,
+  leaves: [tapleaf1, tapleaf2]  // Script leaves
+})
+
+console.log(taprootCtx.tapkey)    // Tweaked public key
+console.log(taprootCtx.cblock)    // Control block for script-path
+console.log(taprootCtx.taptweak)  // Tweak value
+
+// Verify control block
+const isValid = TAPROOT.verify(tapkey, target, cblock)
+```
+
+### Script Detection
+
+```typescript
+import { SCRIPT } from '@vbyte/btc-dev'
+
+// Detect lock script type
+const type = SCRIPT.get_lock_script_type(scriptPubKey)
+// Returns: 'p2pkh' | 'p2sh' | 'p2wpkh' | 'p2wsh' | 'p2tr' | 'opreturn' | null
+
+// Check specific types
+SCRIPT.is_p2wpkh_script(script)  // true/false
+SCRIPT.is_p2tr_script(script)    // true/false
+
+// Get witness version
+const version = SCRIPT.get_lock_script_version(script)
+// Returns: 0 (segwit v0), 1 (taproot), or null (legacy)
+```
+
+### Witness Parsing
+
+```typescript
+import { WITNESS } from '@vbyte/btc-dev'
+
+// Parse witness data from transaction input
+const witnessData = WITNESS.parse(witness)
+
+console.log(witnessData.type)     // 'p2wpkh' | 'p2wsh' | 'p2tr' | 'p2ts' | null
+console.log(witnessData.version)  // 0 | 1 | null
+console.log(witnessData.params)   // Signature and other params
+console.log(witnessData.script)   // Witness script (if p2wsh/p2ts)
+console.log(witnessData.cblock)   // Control block (if p2ts)
+console.log(witnessData.annex)    // Annex data (if present)
+```
+
+### Metadata Utilities
+
+```typescript
+import { META } from '@vbyte/btc-dev'
+
+// Encode/decode locktime (BIP-65)
+const locktime = META.encode_locktime({ type: 'heightlock', height: 800000 })
+const decoded = META.decode_locktime(locktime)
+
+// Encode/decode sequence (BIP-68)
+const sequence = META.encode_sequence({ mode: 'height', height: 144 })  // ~24 hours
+const decodedSeq = META.decode_sequence(sequence)
+
+// Reference pointers
+const outpoint = META.RefPointer.outpoint.encode(txid, vout)
+const inscriptionId = META.RefPointer.record_id.encode(txid, 0)
+const runeId = META.RefPointer.rune_id.encode(840000, 15)
+```
+
+## Security Considerations
+
+- Always validate inputs before signing transactions
+- Never log or expose secret keys
+- Use secure random number generation for key generation
+- Verify signatures after signing to ensure correctness
+- Be aware of sighash flag implications (ANYONECANPAY, SINGLE, NONE)
+
+See [SECURITY.md](./docs/SECURITY.md) for detailed security guidelines.
+
+## Type Definitions
+
+All types are exported from the main module:
+
+```typescript
+import type {
+  TxData,
+  TxInput,
+  TxOutput,
+  SigHashOptions,
+  AddressData,
+  WitnessData,
+  TaprootContext
+} from '@vbyte/btc-dev'
+```
+
+## Dependencies
+
+- `@noble/curves` - Elliptic curve cryptography
+- `@noble/hashes` - Cryptographic hash functions
+- `@scure/btc-signer` - Bitcoin signing utilities
+- `@vbyte/buff` - Buffer manipulation utilities
+- `zod` - Runtime validation schemas
+
+## Development
+
+```bash
+# Run tests
+npm test
+
+# Run specific test file
+npm run script test/path/to/file.ts
+
+# Build the package
+npm run build
+
+# Build and test
+npm run package
+```
+
+## License
+
+CC-BY-1.0

package/dist/const.d.ts

@@ -36,3 +36,6 @@ export declare const TX_SIZE: {
 export declare const SIGHASH_DEFAULT = 1;
 export declare const SIGHASH_SEGWIT: number[];
 export declare const SIGHASH_TAPROOT: number[];
+export declare const MAX_SCRIPT_SIZE = 10000;
+export declare const MAX_VARINT_SIZE = 520000;
+export declare const OP_1_OFFSET = 80;

package/dist/const.js

@@ -1,36 +1,34 @@
 export const COINBASE = {
-    TXID: '00'.repeat(32),
-    VOUT: 0xFFFFFFFF,
+    TXID: "00".repeat(32),
+    VOUT: 0xffffffff,
 };
 export const DEFAULT = {
     LOCKTIME: 0,
-    SEQUENCE: 0xFFFFFFFF,
+    SEQUENCE: 0xffffffff,
     VERSION: 2,
 };
 export const TAPLEAF_VERSIONS = [
-    0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce,
-    0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde,
-    0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee,
-    0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe,
-    0x66, 0x7e, 0x80, 0x84, 0x96, 0x98, 0xba, 0xbc,
-    0xbe
+    0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8,
+    0xda, 0xdc, 0xde, 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0, 0xf2,
+    0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x66, 0x7e, 0x80, 0x84, 0x96, 0x98, 0xba,
+    0xbc, 0xbe,
 ];
 export const TAPLEAF_DEFAULT_VERSION = 0xc0;
 export const LOCK_SCRIPT_TYPE = {
-    P2PKH: 'p2pkh',
-    P2SH: 'p2sh',
-    P2WPKH: 'p2wpkh',
-    P2WSH: 'p2wsh',
-    P2TR: 'p2tr',
-    OPRETURN: 'opreturn',
+    P2PKH: "p2pkh",
+    P2SH: "p2sh",
+    P2WPKH: "p2wpkh",
+    P2WSH: "p2wsh",
+    P2TR: "p2tr",
+    OPRETURN: "opreturn",
 };
 export const SPEND_SCRIPT_TYPE = {
-    P2PKH: 'p2pkh',
-    P2SH: 'p2sh',
-    P2WPKH: 'p2wpkh',
-    P2WSH: 'p2wsh',
-    P2TR: 'p2tr',
-    P2TS: 'p2ts',
+    P2PKH: "p2pkh",
+    P2SH: "p2sh",
+    P2WPKH: "p2wpkh",
+    P2WSH: "p2wsh",
+    P2TR: "p2tr",
+    P2TS: "p2ts",
 };
 export const LOCK_SCRIPT_REGEX = {
     [LOCK_SCRIPT_TYPE.P2PKH]: /^76a914[0-9a-f]{40}88ac$/i,
@@ -40,7 +38,7 @@ export const LOCK_SCRIPT_REGEX = {
     [LOCK_SCRIPT_TYPE.P2TR]: /^5120[0-9a-f]{64}$/i,
     [LOCK_SCRIPT_TYPE.OPRETURN]: /^6a[0-9a-f]{2,}$/i,
 };
-export const SCRIPT_INT_KEY = '';
+export const SCRIPT_INT_KEY = "";
 export const TX_SIZE = {
     GLOBAL_BASE: 8,
     GLOBAL_WIT: 10,
@@ -50,3 +48,6 @@ export const TX_SIZE = {
 export const SIGHASH_DEFAULT = 0x01;
 export const SIGHASH_SEGWIT = [0x01, 0x02, 0x03, 0x81, 0x82, 0x83];
 export const SIGHASH_TAPROOT = [0x00, ...SIGHASH_SEGWIT];
+export const MAX_SCRIPT_SIZE = 10_000;
+export const MAX_VARINT_SIZE = 520_000;
+export const OP_1_OFFSET = 0x50;

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-export * as ADDRESS from './lib/address/index.js';
-export * as META from './lib/meta/index.js';
-export * as SCRIPT from './lib/script/index.js';
-export * as SIGHASH from './lib/sighash/index.js';
-export * as SIGNER from './lib/signer/index.js';
-export * as TAPROOT from './lib/taproot/index.js';
-export * as TX from './lib/tx/index.js';
-export * as WITNESS from './lib/witness/index.js';
-export * as CONST from './const.js';
-export * as SCHEMA from './schema/index.js';
-export type * from './types/index.js';
+export * as CONST from "./const.js";
+export * as ADDRESS from "./lib/address/index.js";
+export * as META from "./lib/meta/index.js";
+export * as SCRIPT from "./lib/script/index.js";
+export * as SIGHASH from "./lib/sighash/index.js";
+export * as SIGNER from "./lib/signer/index.js";
+export * as TAPROOT from "./lib/taproot/index.js";
+export * as TX from "./lib/tx/index.js";
+export * as WITNESS from "./lib/witness/index.js";
+export * as SCHEMA from "./schema/index.js";
+export type * from "./types/index.js";

package/dist/index.js

@@ -1,10 +1,10 @@
-export * as ADDRESS from './lib/address/index.js';
-export * as META from './lib/meta/index.js';
-export * as SCRIPT from './lib/script/index.js';
-export * as SIGHASH from './lib/sighash/index.js';
-export * as SIGNER from './lib/signer/index.js';
-export * as TAPROOT from './lib/taproot/index.js';
-export * as TX from './lib/tx/index.js';
-export * as WITNESS from './lib/witness/index.js';
-export * as CONST from './const.js';
-export * as SCHEMA from './schema/index.js';
+export * as CONST from "./const.js";
+export * as ADDRESS from "./lib/address/index.js";
+export * as META from "./lib/meta/index.js";
+export * as SCRIPT from "./lib/script/index.js";
+export * as SIGHASH from "./lib/sighash/index.js";
+export * as SIGNER from "./lib/signer/index.js";
+export * as TAPROOT from "./lib/taproot/index.js";
+export * as TX from "./lib/tx/index.js";
+export * as WITNESS from "./lib/witness/index.js";
+export * as SCHEMA from "./schema/index.js";

package/dist/lib/address/api.d.ts

@@ -1,4 +1,4 @@
-import { Bytes } from '@vbyte/buff';
-import type { AddressInfo, ChainNetwork } from '../../types/index.js';
+import { type Bytes } from "@vbyte/buff";
+import type { AddressInfo, ChainNetwork } from "../../types/index.js";
 export declare function get_address(script: Bytes, network?: ChainNetwork): string;
 export declare function parse_address(address: string): AddressInfo;

package/dist/lib/address/api.js

@@ -1,17 +1,17 @@
-import { Buff } 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';
-export function get_address(script, network = 'main') {
+import { Buff } from "@vbyte/buff";
+import { LOCK_SCRIPT_TYPE } from "../../const.js";
+import { get_lock_script_type } from "../../lib/script/lock.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 { get_address_info } from "./util.js";
+export function get_address(script, network = "main") {
     const bytes = Buff.bytes(script);
     const type = get_lock_script_type(bytes);
     if (type === null)
-        throw new Error('unknown locking script: ' + bytes.hex);
+        throw new Error("Unknown or unsupported locking script type");
     switch (type) {
         case LOCK_SCRIPT_TYPE.P2PKH:
             return P2PKH.encode_address(script, network);
@@ -24,7 +24,7 @@ export function get_address(script, network = 'main') {
         case LOCK_SCRIPT_TYPE.P2TR:
             return P2TR.encode_address(script, network);
         default:
-            throw new Error('unknown script type: ' + type);
+            throw new Error(`unknown script type: ${type}`);
     }
 }
 export function parse_address(address) {

package/dist/lib/address/encode.d.ts

@@ -1,3 +1,3 @@
-import type { EncoderConfig } from '../../types/address.js';
+import type { EncoderConfig } from "../../types/address.js";
 export declare function decode_address(address: string): EncoderConfig;
 export declare function encode_address(config: EncoderConfig): string;

package/dist/lib/address/encode.js

@@ -1,34 +1,34 @@
-import { Buff } from '@vbyte/buff';
-import { Assert, B58chk, Bech32, Bech32m } from '@vbyte/micro-lib';
+import { Buff } from "@vbyte/buff";
+import { Assert, B58chk, Bech32, Bech32m } from "@vbyte/micro-lib";
 const ENCODING_REGEX = {
     base58: /^[13mn2][a-km-zA-HJ-NP-Z1-9]{25,34}$/,
     bech32: /^(bc|tb|bcrt)1q[ac-hj-np-z02-9]{6,87}$/,
-    bech32m: /^(bc|tb|bcrt)1p[ac-hj-np-z02-9]{6,87}$/
+    bech32m: /^(bc|tb|bcrt)1p[ac-hj-np-z02-9]{6,87}$/,
 };
 const VERSION = {
     bech32: 0,
-    bech32m: 1
+    bech32m: 1,
 };
 export function decode_address(address) {
     const format = get_address_format(address);
     if (format === null)
-        throw new Error('unrecognized address format: ' + format);
-    if (format === 'base58')
+        throw new Error(`unrecognized address format: ${address}`);
+    if (format === "base58")
         return base58_decode(address);
-    if (format === 'bech32')
+    if (format === "bech32")
         return bech32_decode(address);
-    if (format === 'bech32m')
+    if (format === "bech32m")
         return bech32m_decode(address);
-    throw new Error('unable to find a matching address configuration');
+    throw new Error("unable to find a matching address configuration");
 }
 export function encode_address(config) {
-    if (config.format === 'base58')
+    if (config.format === "base58")
         return base58_encode(config);
-    if (config.format === 'bech32')
+    if (config.format === "bech32")
         return bech32_encode(config);
-    if (config.format === 'bech32m')
+    if (config.format === "bech32m")
         return bech32m_encode(config);
-    throw new Error('unrecognized encoding format: ' + config.format);
+    throw new Error(`unrecognized encoding format: ${config.format}`);
 }
 function get_address_format(address) {
     for (const [format, regex] of Object.entries(ENCODING_REGEX)) {
@@ -38,8 +38,8 @@ function get_address_format(address) {
     return null;
 }
 function base58_encode(config) {
-    Assert.ok(config.format === 'base58', 'encoding mismatch');
-    Assert.exists(config.version, 'must specify a version');
+    Assert.ok(config.format === "base58", "encoding mismatch");
+    Assert.exists(config.version, "must specify a version");
     const bytes = Buff.join([config.version, config.data]);
     return B58chk.encode(bytes);
 }
@@ -47,11 +47,11 @@ function base58_decode(encoded) {
     const bytes = B58chk.decode(encoded);
     const data = bytes.slice(1);
     const version = bytes[0];
-    return { data, format: 'base58', version };
+    return { data, format: "base58", version };
 }
 function bech32_encode(config) {
-    Assert.ok(config.format === 'bech32', 'encoding mismatch');
-    Assert.exists(config.prefix, 'prefix is required');
+    Assert.ok(config.format === "bech32", "encoding mismatch");
+    Assert.exists(config.prefix, "prefix is required");
     const bytes = Buff.bytes(config.data);
     const words = Bech32.to_words(bytes);
     return Bech32.encode(config.prefix, [VERSION.bech32, ...words]);
@@ -59,13 +59,13 @@ function bech32_encode(config) {
 function bech32_decode(encoded) {
     const { prefix, words } = Bech32.decode(encoded);
     const [version, ...rest] = words;
-    Assert.ok(version === VERSION.bech32, 'bech32 version mismatch');
+    Assert.ok(version === VERSION.bech32, "bech32 version mismatch");
     const data = Bech32.to_bytes(rest);
-    return { data, format: 'bech32', prefix, version };
+    return { data, format: "bech32", prefix, version };
 }
 function bech32m_encode(config) {
-    Assert.ok(config.format === 'bech32m', 'encoding mismatch');
-    Assert.exists(config.prefix, 'prefix is required');
+    Assert.ok(config.format === "bech32m", "encoding mismatch");
+    Assert.exists(config.prefix, "prefix is required");
     const bytes = Buff.bytes(config.data);
     const words = Bech32m.to_words(bytes);
     return Bech32m.encode(config.prefix, [VERSION.bech32m, ...words]);
@@ -73,7 +73,7 @@ function bech32m_encode(config) {
 function bech32m_decode(encoded) {
     const { prefix, words } = Bech32m.decode(encoded);
     const [version, ...rest] = words;
-    Assert.ok(version === VERSION.bech32m, 'bech32m version mismatch');
+    Assert.ok(version === VERSION.bech32m, "bech32m version mismatch");
     const data = Bech32m.to_bytes(rest);
-    return { data, format: 'bech32m', prefix, version };
+    return { data, format: "bech32m", prefix, version };
 }

package/dist/lib/address/index.d.ts

@@ -1,6 +1,6 @@
-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 * from './api.js';
+export * from "./api.js";
+export { P2PKH } from "./p2pkh.js";
+export { P2SH } from "./p2sh.js";
+export { P2TR } from "./p2tr.js";
+export { P2WPKH } from "./p2wpkh.js";
+export { P2WSH } from "./p2wsh.js";