Premium Web3 Toolkit 8 tools · 100% client-side
All Toolkits

Build on Ethereum & friends
with a sharper toolkit.

Eight focused, browser-native Web3 tools for developers — validate wallets, hash with Keccak-256, decode ABIs, look up chain IDs, calculate gas, and compute ENS namehash. Everything runs locally in your browser. No data ever leaves your machine.

Keccak-256 verified EIP-55 checksum ENS namehash No API keys 30+ chains

◆Wallet Address Validator

Paste any wallet address. The tool auto-detects the chain (Ethereum, Bitcoin, Solana, Polygon, BSC, and other EVM chains), validates the format, and verifies the EIP-55 checksum for Ethereum-style addresses.

Input Address auto-detect

Try: 0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed, 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045, bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq

Detection Result

◇
Enter an address to see chain detection, format validation, and checksum status.

⇄ETH Unit Converter

Convert between Ethereum's denomination units — wei, kwei, mwei, gwei, finney, and ether. Live conversion as you type. Includes a static ETH/USD rate (live rates require a price-feed API).

Source Value live

Live rates require a price-feed API. Adjust this static rate for rough USD estimates.

Converted Values

wei0
kwei0
mwei0
gwei0
finney0
ether0
Estimated USD value$0.00

⛽Gas Tracker & Calculator

Static demo of network gas tiers and estimated transaction costs. Calculate custom gas costs by entering your own gas price and limit. All values are illustrative — real-time gas requires an oracle API.

Sample Network Tiers static

Slow
8
~3-5 min
Standard
15
~1 min
Fast
25
~15 sec
Instant
40
~next block
! These are static sample values for demonstration. Real-time gas prices require a live oracle (Etherscan Gas API, ETH Gas Station, or node RPC). Pre-EIP-1559 model shown for clarity.

Custom Cost Calculator

Transaction Cost
0.000315 ETH
$0.77

Estimated Costs by Tx Type

TransactionGasETHUSD
i Gas limits are typical estimates. Actual consumption depends on the contract, calldata, and storage state.

#Keccak-256 Hasher

Ethereum's hash function. Implemented in pure JavaScript using the Keccak-f[1600] permutation with the original Keccak padding (0x01) — not NIST SHA-3 (which uses 0x06). Hash text or hex input, and compare two inputs side by side.

Input keccak-256

UTF-8 bytes are hashed directly.

Output

keccak256("") will appear here…

Compare Two Inputs

Hashes will appear here.

{ }ABI Formatter

Paste a raw JSON ABI (smart contract interface). The tool parses, validates, and renders it as a human-readable list of functions, events, constructors, and fallbacks — with full type signatures.

Raw ABI JSON

Parsed Interface

{ }
Paste a valid ABI JSON array to see the parsed contract interface.

⛓Chain ID Lookup

Browse 30+ blockchain networks with their chain IDs, native currencies, RPC URLs, and explorers. Search by name or chain ID. Click any chain card to copy its chain ID to your clipboard.

0
Networks
0
Mainnets
0
Testnets
click
to copy ID

⌬Token Amount Formatter

Convert between human-readable token amounts and raw smallest-unit (wei) values. Essential for ERC-20 transactions, where most tokens use 18 decimals but some (like USDC) use 6.

Conversion Mode

Common values: ETH=18, USDC=6, WBTC=8, DAI=18
Raw Amount (wei)
1500000000000000000
1.5 ETH at 18 decimals

Quick Reference

1 ETH (18 dec)1000000000000000000
1 USDC (6 dec)1000000
1 WBTC (8 dec)100000000
1 DAI (18 dec)1000000000000000000
0.5 ETH (18 dec)500000000000000000
0.001 ETH (18 dec)1000000000000000
i The raw value is what you actually pass to a contract's transfer() function — contracts never see decimals, only the integer smallest-unit amount.

@ENS / SNS Helper

Validate ENS name format, compute the ENS namehash (EIP-137) used as the storage key in the ENS registry, and review typical gas costs for ENS operations. Real on-chain resolution requires a node RPC; this tool computes the algorithmic namehash locally.

ENS Name namehash

Algorithm: namehash("") = 32 zero bytes; namehash(name) = keccak256(namehash(parent) || keccak256(label))
Valid ENS name format.
0x...

Namehash Computation Steps

Enter an ENS name to see the step-by-step namehash computation.

Typical ENS Gas Costs static

Register 5+ char name
ETHRegistrarController
~280,000 gas
Resolve name (addr)
ENS resolver lookup
~50,000 gas
Set resolver record
setAddr() transaction
~55,000 gas
Set text record
setText() transaction
~58,000 gas
Transfer subdomain
subnode owner change
~80,000 gas
i The Ethereum Name Service (ENS) maps human-readable names like vitalik.eth to addresses, content hashes, and other records. The namehash is the deterministic 256-bit key used to look up records in the ENS registry.

Frequently Asked Questions

Everything you need to know about this Web3 toolkit and how it works.

What is Keccak-256 and how is it different from SHA-3?+
Keccak-256 is the hash function used by Ethereum for addresses, transactions, and smart contracts. SHA-3-256 is the NIST-standardized version of Keccak. They use the same Keccak-f[1600] permutation but differ in padding: Ethereum's Keccak-256 uses the original 0x01 padding bit, while SHA-3 uses 0x06 as specified in FIPS 202. Because of this difference, the two algorithms produce different hashes for the same input, so they are not interchangeable. This toolkit implements the Ethereum variant — the one used for EIP-55 checksums and ENS namehash.
How does EIP-55 checksum work?+
EIP-55 adds case-based checksums to Ethereum addresses. The lowercase hex address (without 0x prefix) is hashed with Keccak-256. Then for each character in the address, if the character is a letter (a-f) and the corresponding nibble in the hash is 8 or higher, the letter is capitalized; otherwise it stays lowercase. Digits are never capitalized. To verify, you recompute the checksum and compare it to the input. This catches single-character typos and many transpositions without changing the address length or the underlying bytes. For example, 0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed is correctly checksummed; flipping any single letter case will fail validation.
What is a chain ID?+
A chain ID is a unique integer that identifies a blockchain network. It was introduced in EIP-155 to prevent transaction replay across different chains. For example, Ethereum Mainnet is 1, BSC is 56, Polygon is 137, and Arbitrum One is 42161. When you sign a transaction, the chain ID is included in the signed data, so a transaction valid on one chain cannot be replayed on another. Wallets use the chain ID to route transactions to the correct network, and dApps use it to detect which network the user is connected to before triggering contract calls.
How are gas fees calculated?+
Gas fees are calculated as gas limit multiplied by gas price. The gas limit is the maximum amount of gas a transaction can consume (21,000 for a simple ETH transfer, more for contract interactions). The gas price is what you pay per unit of gas, measured in gwei (1 gwei = 10^-9 ETH). Total cost in ETH = (gas limit × gas price in gwei) / 10^9. Since EIP-1559, the gas price is split into a base fee (burned) and an optional priority fee (tip to the validator). This toolkit shows the simpler pre-EIP-1559 model for clarity, but the math is the same: limit × price per unit.
Is my data sent to a server?+
No. Every tool in the Premium Web3 Toolkit runs entirely in your browser using client-side JavaScript. Your addresses, ABI JSON, text inputs, and other data never leave your device. The Keccak-256, EIP-55, and ENS namehash implementations are all inlined and execute locally. This makes the toolkit safe to use with sensitive development data. The Gas Tracker uses static demo values because real-time gas data would require an external API call. If you need live data, you can download the HTML and wire in your own RPC or oracle endpoint.
How does the ENS namehash algorithm work?+
The ENS namehash is a recursive algorithm defined in EIP-137 that produces a 256-bit hash for any ENS name. It starts with 32 zero bytes for the empty name. Then for each label (working from right to left, e.g. for vitalik.eth it processes 'eth' first then 'vitalik'), it computes: node = keccak256(node || keccak256(label)). The label is first normalized (lowercased here for simplicity; full ENS normalization uses Unicode NFKC) and hashed with Keccak-256. The final 32-byte value is the namehash used as the storage key in the ENS registry smart contract. This toolkit shows each intermediate step so you can verify the algorithm by hand.
Copied