Address Format

An address format is the standardized representation of a public identifier on a blockchain, derived from a user's public key through cryptographic hashing. It serves as the destination for transactions, analogous to an account number in traditional finance. Different blockchains employ distinct formats, such as the 0x-prefixed 40-character hexadecimal strings on Ethereum or the alphanumeric strings starting with 1, 3, or bc1 on Bitcoin. The format includes built-in checks, like checksums, to prevent errors from typos when sending funds.

The creation of an address follows a deterministic process. A user's private key generates a corresponding public key. This public key is then processed through a one-way hash function (like Keccak-256 for Ethereum or SHA-256 followed by RIPEMD-160 for Bitcoin). The resulting hash is encoded into the final human-readable string using a specific scheme, such as Base58Check or Bech32. This encoding minimizes ambiguity (e.g., excluding similar-looking characters like '0' and 'O') and embeds error detection.

Key variations exist even within a single network. Bitcoin's evolution introduced multiple formats: the legacy P2PKH address (starting with '1'), the P2SH address for smart contracts (starting with '3'), and the native SegWit Bech32 address (starting with 'bc1'). Ethereum primarily uses the 0x-prefixed hex format, but other EVM-compatible chains may use identical formats, making chain context critical. Address format is therefore a fundamental piece of data that specifies both the destination and the necessary rules for constructing a valid transaction.

An address format is the specific encoding and structural standard used to represent a destination for cryptocurrency transactions on a blockchain network. It is a human-readable string derived from a public key through a series of cryptographic hashes and encoding steps. Different blockchains use distinct formats—such as Bitcoin's legacy 1... or SegWit bc1... addresses, and Ethereum's 0x... hexadecimal format—which are designed to prevent errors, ensure security, and signal compatibility with specific network features like smart contracts or upgraded transaction types.

The creation of an address typically follows a multi-step process. First, a public key is generated from a private key using elliptic curve cryptography. This public key is then hashed, often with algorithms like SHA-256 and RIPEMD-160, to create a shorter, more secure public key hash. Finally, this hash is encoded into a string using a scheme like Base58Check or Bech32, which includes a version byte (to denote the network) and a checksum to detect typos. This checksum is critical for user safety, as entering an invalid address will almost certainly result in a failed validation, protecting funds from being sent into oblivion.

Common formats include Bitcoin's P2PKH (Pay-to-Public-Key-Hash, starting with '1'), P2SH (Pay-to-Script-Hash, starting with '3'), and Bech32 (native SegWit, starting with 'bc1q'). Ethereum uses a simpler hex format derived from the last 20 bytes of the Keccak-256 hash of the public key, prefixed with '0x'. Other chains, like Litecoin (starting with 'L' or 'M') or Binance Smart Chain (BSC), often adapt these existing standards. Understanding the format is essential for interoperability; sending Bitcoin to an Ethereum address will result in permanent loss of funds, as the networks and validation rules are incompatible.

Address formats have evolved to support new functionalities and improve efficiency. The shift from Bitcoin's P2PKH to Bech32 for SegWit transactions is a prime example. Bech32 addresses offer several advantages: they are case-insensitive, more resistant to typing errors, and enable smaller transaction sizes, which lowers fees. Furthermore, hierarchical deterministic (HD) wallets use standardized derivation paths (defined in BIP32/BIP44) to generate a tree of addresses from a single seed, all adhering to the chain's chosen format. This allows users to manage countless addresses securely under one backup phrase.

For developers and users, handling addresses correctly is paramount. Wallets and exchanges must rigorously validate checksums and network prefixes. Services often use address explorers to decode and display the underlying script type and transaction history. When integrating blockchain functionality, libraries like bitcoinjs-lib or web3.js provide tools for address generation, validation, and conversion between formats. As the ecosystem grows with new layers and sidechains, standardized address formats like those proposed in EIP-55 for Ethereum checksums become increasingly important for security and user experience across different applications and wallets.

The evolution of address formats refers to the chronological development of cryptographic identifiers used to send and receive assets on a blockchain, driven by the need for enhanced security, interoperability, and human readability. This progression is marked by distinct generations: from the raw public key hashes of early systems to modern, feature-rich formats that encode additional metadata like network information and contract interfaces. Each stage represents a critical response to the growing complexity and expanding use cases of decentralized networks.

The first major generation is exemplified by Bitcoin's Pay-to-Public-Key-Hash (P2PKH) addresses, like 1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2. These are created by applying a series of cryptographic hash functions (SHA-256 and RIPEMD-160) to a public key, then encoding the result with a checksum using Base58Check. This format improved security by shielding the public key until the moment of spending and minimized human error in transcription. A key innovation was the version byte, a prefix that identified the network (e.g., mainnet vs. testnet).

The rise of smart contract platforms and scaling solutions necessitated more sophisticated formats. Ethereum introduced hexadecimal addresses (e.g., 0x742d35Cc6634C0532925a3b844Bc9e...), which are simply the last 20 bytes of a public key's Keccak-256 hash, prefixed with 0x. A significant usability leap came with EIP-55, which introduced mixed-case checksumming for hexadecimal addresses to prevent typos. For improved cross-chain interoperability, formats like the Bech32 address (e.g., bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq) were developed, featuring superior error detection and the native segregation of witness data for protocols like SegWit.

The latest evolution focuses on abstraction and simplification through account abstraction and smart contract wallets. Standards like ERC-4337 on Ethereum allow addresses to be programmable smart contracts themselves, enabling features like social recovery, batch transactions, and gas sponsorship. Furthermore, projects are developing universal identifiers that are chain-agnostic, such as Decentralized Identifiers (DIDs) and ENS domains (e.g., alice.eth), which map human-readable names to machine-readable addresses across multiple blockchains, abstracting the underlying complexity from end-users.