ETH Address Toolkit
Convert and validate Ethereum addresses. Get EIP-55 checksummed, lowercase, bytes32, and short display formats — with full checksum verification.
How EIP-55 Checksum Works
1. Lowercase the 40-character hex address (no 0x prefix).
2. Compute Keccak-256 of that lowercase string (treating it as ASCII/UTF-8 bytes).
3. For each hex letter in the address: if the corresponding nibble in the hash is ≥ 8, uppercase it; otherwise lowercase.
Result: a mixed-case address that encodes its own checksum — incorrect digit changes cause a checksum mismatch.
Address Format Reference
| Format | When to Use | Standard? |
|---|---|---|
| EIP-55 checksummed | Default for wallets, explorers, and user-facing UI | Yes (EIP-55) |
| Lowercase 0x… | Keccak-256 computation, comparisons, JSON output | Common |
| Uppercase 0X… | Legacy systems, some hardware wallets | Non-standard |
| bytes32 (left-padded) | abi.encode(), contract storage reads, calldata | Solidity ABI |
| Short (0x1234…5678) | UI display in wallets and dApps to save space | UI convention |
EIP-55 Mixed-Case Checksum Addressing
EIP-55, proposed by Vitalik Buterin in 2016, introduced a simple and backwards-compatible checksum for Ethereum addresses. The algorithm works entirely in hex character space: it lowercases the 40-character address, hashes it with Keccak-256, and uses the hash nibbles to determine which letters to capitalize. This produces a visually unique encoding for each address that encodes integrity information. A single wrong character almost always breaks the checksum, catching common copy-paste mistakes or hardware faults.
When to Use Each Address Format
Use the EIP-55 checksummed format as your default for all user-facing UI, clipboard sharing, and display in wallets and explorers. Use lowercase when computing the EIP-55 checksum itself, passing to keccak256() in Solidity, or storing in databases where case-insensitive comparison is needed. Use the bytes32 (left-padded) format when manually reading storage slots with eth_getStorageAt or decoding ABI-encoded calldata. Use the shortened format (0x1234…5678) only for UI display where space is limited — never for actual transactions.
Address Security Best Practices
Always verify the full address before signing any transaction — the short display format can hide middle digits that differ. Enable EIP-55 checksum validation in any address input field. Be aware of address poisoning attacks where attackers send dust transactions from addresses with the same first and last few characters as a legitimate address. Hardware wallets display the full address on-device before signing — always verify all 40 characters against a trusted source for large transactions.
Frequently Asked Questions
What is EIP-55 address checksum?
EIP-55 (by Vitalik Buterin) defines a mixed-case encoding for Ethereum addresses that embeds a checksum. The address is lowercase-normalized, then Keccak-256 is computed over the hex string. For each hex letter, if the corresponding nibble in the hash is >= 8, the letter is uppercased; otherwise it stays lowercase. This lets any program detect a typo in a hex address with ~99.986% probability.
Does it matter if I use uppercase or lowercase Ethereum addresses?
At the protocol level, Ethereum addresses are case-insensitive — 0xabcd and 0xABCD refer to the same account. However, EIP-55 checksummed addresses (mixed-case) allow wallets and applications to validate that an address was not corrupted. Using lowercase everywhere is safe, but sharing a checksummed address is considered best practice and required by several wallets.
What is the bytes32 format used for?
When an address is stored in a Solidity mapping or passed as an abi.encode() argument, it is padded to 32 bytes by left-padding with zeros. The bytes32 format shown here (0x + 24 zeros + 40-char address) is what you would see reading a contract's storage slot or examining ABI-encoded calldata containing an address parameter.
How do I validate an Ethereum address programmatically?
A valid Ethereum address is a 0x-prefixed 40-character hexadecimal string (20 bytes). To validate the checksum, compute checksumAddress(addr) and compare it to the input. In web3.js: web3.utils.isAddress(addr). In ethers.js: ethers.utils.isAddress(addr). In Solidity: the address type inherently validates format at compile time.
Why do some Ethereum addresses start with 0x0000?
Addresses with many leading zeros are called 'vanity addresses' or were created by miners to reduce calldata gas costs (zero bytes cost 4 gas vs 16 for non-zero in calldata). The zero address 0x0000000000000000000000000000000000000000 is special — ETH sent there is permanently burned. Contract creation with CREATE2 can precompute addresses with specific prefixes.