Address Operations

/**
 * Decode address with base58 specification, return address version and address hash if valid
 * @param address - Base58Check encoded address string
 * @returns Object containing hash and version
 * @throws Error if address is invalid
 */
function fromBase58Check(address: string): Base58CheckResult;

interface Base58CheckResult {
  /** Address hash (20 bytes) */
  hash: Buffer;
  /** Address version: 0x00 for P2PKH, 0x05 for P2SH */
  version: number;
}

import { address } from 'bitcoinjs-lib';

// Decode P2PKH address
const p2pkhResult = address.fromBase58Check('1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa');
console.log(p2pkhResult.version); // 0 (P2PKH)
console.log(p2pkhResult.hash.toString('hex')); // Hash160 of public key

// Decode P2SH address
const p2shResult = address.fromBase58Check('3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy');
console.log(p2shResult.version); // 5 (P2SH)
console.log(p2shResult.hash.toString('hex')); // Hash160 of script

/**
 * Encode address hash to base58 address with version
 * @param hash - Hash to encode (typically 20 bytes)
 * @param version - Address version (0x00 for P2PKH, 0x05 for P2SH)
 * @returns Base58Check encoded address string
 */
function toBase58Check(hash: Buffer, version: number): string;

import { address, crypto } from 'bitcoinjs-lib';

// Create P2PKH address from public key
const pubkey = Buffer.from('03...', 'hex');
const hash = crypto.hash160(pubkey);
const p2pkhAddress = address.toBase58Check(hash, 0x00);

// Create P2SH address from script
const redeemScript = Buffer.from('5221...', 'hex');
const scriptHash = crypto.hash160(redeemScript);
const p2shAddress = address.toBase58Check(scriptHash, 0x05);

/**
 * Decode address with bech32 specification, return address version, address prefix and address data if valid
 * @param address - Bech32 encoded address string
 * @returns Object containing version, prefix, and data
 * @throws Error if address is invalid
 */
function fromBech32(address: string): Bech32Result;

interface Bech32Result {
  /** Address version: 0x00 for P2WPKH/P2WSH, 0x01 for P2TR */
  version: number;
  /** Address prefix: 'bc' for mainnet, 'tb' for testnet */
  prefix: string;
  /** Address data: 20 bytes for P2WPKH, 32 bytes for P2WSH/P2TR */
  data: Buffer;
}

import { address } from 'bitcoinjs-lib';

// Decode P2WPKH address
const p2wpkhResult = address.fromBech32('bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4');
console.log(p2wpkhResult.version); // 0
console.log(p2wpkhResult.prefix); // 'bc'
console.log(p2wpkhResult.data.length); // 20 bytes

// Decode P2TR address
const p2trResult = address.fromBech32('bc1p5d7rjq7g6rdk2yhzks9smlaqtedr4dekq08ge8ztwac72sfr9rusxg3297');
console.log(p2trResult.version); // 1
console.log(p2trResult.data.length); // 32 bytes

/**
 * Encode address hash to bech32 address with version and prefix
 * @param data - Data to encode (20 bytes for P2WPKH, 32 bytes for P2WSH/P2TR)
 * @param version - Address version (0 for P2WPKH/P2WSH, 1 for P2TR)
 * @param prefix - Network prefix ('bc' for mainnet, 'tb' for testnet)
 * @returns Bech32 encoded address string
 */
function toBech32(data: Buffer, version: number, prefix: string): string;

import { address, crypto } from 'bitcoinjs-lib';

// Create P2WPKH address
const pubkey = Buffer.from('03...', 'hex');
const pubkeyHash = crypto.hash160(pubkey);
const p2wpkhAddress = address.toBech32(pubkeyHash, 0, 'bc');

// Create P2TR address
const internalPubkey = Buffer.from('abc123...', 'hex');
const p2trAddress = address.toBech32(internalPubkey, 1, 'bc');

/**
 * Decode address from output script with network, return address if matched
 * @param output - Output script buffer
 * @param network - Network configuration (defaults to bitcoin mainnet)
 * @returns Address string corresponding to the script
 * @throws Error if script doesn't match known address types
 */
function fromOutputScript(output: Buffer, network?: Network): string;

import { address, networks } from 'bitcoinjs-lib';

// Convert P2PKH script to address
const p2pkhScript = Buffer.from('76a914...88ac', 'hex');
const p2pkhAddr = address.fromOutputScript(p2pkhScript, networks.bitcoin);

// Convert P2SH script to address
const p2shScript = Buffer.from('a914...87', 'hex');
const p2shAddr = address.fromOutputScript(p2shScript, networks.bitcoin);

// Convert P2WPKH script to address
const p2wpkhScript = Buffer.from('0014...', 'hex');
const p2wpkhAddr = address.fromOutputScript(p2wpkhScript, networks.bitcoin);

/**
 * Encode address to output script with network, return output script if address matched
 * @param address - Address string to convert
 * @param network - Network configuration (defaults to bitcoin mainnet)
 * @returns Output script buffer corresponding to the address
 * @throws Error if address format is invalid or unsupported
 */
function toOutputScript(address: string, network?: Network): Buffer;

import { address, networks } from 'bitcoinjs-lib';

// Convert P2PKH address to script
const p2pkhScript = address.toOutputScript('1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa', networks.bitcoin);
console.log(p2pkhScript.toString('hex')); // '76a914...'

// Convert P2SH address to script
const p2shScript = address.toOutputScript('3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy', networks.bitcoin);
console.log(p2shScript.toString('hex')); // 'a914...'

// Convert Bech32 address to script
const p2wpkhScript = address.toOutputScript('bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4', networks.bitcoin);
console.log(p2wpkhScript.toString('hex')); // '0014...'

interface Network {
  messagePrefix: string;
  bech32: string;
  bip32: { public: number; private: number };
  pubKeyHash: number;
  scriptHash: number;
  wif: number;
}