Web3 & Blockchain Tools
EVM, Solana, Cosmos, and multi-chain utilities for addresses, ABIs, calldata, IBC denoms, Anchor IDLs, NFT metadata, and Merkle proofs — all offline in your browser.
What Web3 tools should every blockchain developer keep at hand?
Most Web3 engineering boils down to encoding and decoding — translating between human-readable data (an address, a method name, a token amount) and the wire formats that blockchains and wallets actually consume (checksummed hex, Bech32, Base58, 4-byte selectors, ABI-encoded calldata). The category collects the conversions you reach for weekly across EVM, Solana, and Cosmos, plus a few higher-level builders for EIP-712 signing, NFT metadata, and Merkle proofs that tend to be scattered across paywalled dashboards or GitHub snippets.
Everything is client-side. Paste a mainnet address, a raw transaction calldata, a private contract ABI, or a seed list for an airdrop tree without worrying about it hitting our servers. The tools are built for two workflows — incident response ("what does this transaction actually do") and day-to-day dApp development ("let me preview this EIP-712 payload before I pipe it into Wagmi").
EVM: units, ABIs, calldata
Wei / Gwei / Ether Converter handles the unit math that trips up almost every new Solidity developer — BigNumber-safe, no floating-point drift, accepts pasted values in any unit and shows them in all three. ABI Decoder & Encoder takes a JSON ABI and a target function to decode a hex payload or produce one from UI inputs. When you only have raw calldata from a block explorer, Function Selector Lookup resolves the first 4 bytes against a local signature database, and Calldata Decoder chains that resolution into a full parameter breakdown. Event Log Decoder does the same for the output side — ERC-20 Transfer, ERC-721 Approval, or any custom event — using an ABI event fragment and the Topic0 hash.
Solana: lamports, Base58, Anchor
Solana Lamports Converter is the counterpart to the Wei converter — lamports to SOL with the correct 1e9 scale and no precision loss on account rent math. Solana Address Validator checks Base58 encoding and flags whether the input looks like a program ID, a PDA, or a standard wallet public key. Anchor IDL Decoder is the specialist tool: paste an IDL JSON pulled from a deployed program and browse every instruction, account struct, type definition, and PDA seed with a navigable outline. That last part is what is missing from most block explorers and IDE plugins today.
Cosmos: Bech32, IBC, CosmWasm
Bech32 Address Converter switches a single account key between Cosmos-family prefixes — cosmos1…, osmo1…, juno1…, neutron1…, plus dual-chain prefixes like Kaia (klay) and XPLA. Cosmos IBC Denom Parser takes one of those opaque ibc/27394FB… denom hashes and decodes it back into channel, port, and base denom, which is what you need when you are untangling a cross-chain transfer that landed on the wrong chain. CosmWasm Schema Validator is the contract-level companion — drop in an ExecuteMsg or QueryMsg schema and sample payloads to verify against your contract's generated schema.
Multi-chain & address safety
Multi-chain Address Validator accepts any string and auto-detects which chains consider it a valid address — BTC (legacy, SegWit, Taproot), ETH, SOL, Cosmos prefixes, and more — which is a cheap sanity check before you sign or fire off a cross-chain transfer. Wallet Address Format Converter covers the niche case of chains that expose both EVM and Bech32 representations of the same key (Kaia, XPLA, some Cosmos EVM deployments) so you can see both views side by side. Ethereum Address Checksum runs an input through EIP-55 and loudly rejects addresses that would have failed the hand-type check in a wallet UI.
Signing, NFTs, Merkle proofs
EIP-712 Typed Data Builder lets you assemble the domain, types, and message that a wallet such as MetaMask or Rabby will ask the user to sign, with a live preview of the canonical JSON before you pipe it into the SDK. NFT Metadata Builder handles the off-chain half of ERC-721, ERC-1155, and Metaplex minting — attributes, external URL, animation URL, preview, and the schema differences between each standard. Token Decimals Calculator prevents one of the most common production bugs — sending 1 USDC (6 decimals) when you meant 1e18 — by making the raw ↔ human conversion explicit per token. Merkle Tree Generator builds a root from an address / amount list and exports per-leaf proofs compatible with OpenZeppelin MerkleProof, which is the airdrop pattern the majority of EVM protocols use.
Tools in this category
Every tool runs locally. No RPC, no wallet connection, no server roundtrips.
Ethereum Address Checksum
Convert Ethereum addresses to EIP-55 checksum format and validate address integrity.
Crypto Unit Converter
Convert between ETH, Wei, Gwei, BTC, and Satoshi units with precise calculations.
BIP39 Mnemonic Generator
Generate and validate BIP39 mnemonic seed phrases (12/24 words) and convert to seed.
Multi-chain Address Validator
Auto-detect and validate BTC, ETH, SOL, Cosmos and dozens of other blockchain addresses in one go.
Wallet Address Format Converter
Convert between EVM hex and Bech32 (Kaia, XPLA, Cosmos prefix) formats for dual-chain wallets.
Wei / Gwei / Ether Converter
Convert between Wei, Gwei, and Ether with precision. Decimal math without floating-point errors.
ABI Decoder & Encoder
Decode and encode Solidity function call data against an ABI. Supports tuples, arrays, and custom types.
Function Selector Lookup
Look up 4-byte function selectors (0x23b872dd → transferFrom) from a local 4byte-directory database.
Calldata Decoder
Paste transaction input data and decode function name, parameters, and argument types — no RPC needed.
Solana Lamports Converter
Convert between lamports and SOL with precise arithmetic. Works with transaction fees and account rent.
Solana Address Validator
Validate Solana Base58 addresses and detect whether it is a program ID, PDA, or standard wallet key.
Bech32 Address Converter
Convert between Cosmos-style Bech32 prefixes (cosmos1…, osmo1…, juno1…) while preserving the underlying key.
Cosmos IBC Denom Parser
Parse IBC denom hashes (ibc/…) back to the channel, port, and base denom of the originating chain.
EIP-712 Typed Data Builder
Build EIP-712 typed data payloads for wallet signing. Domain, types, and message with JSON preview.
Event Log Decoder
Decode ERC-20 Transfer, ERC-721 Approval, and other event logs by Topic0 and an ABI event fragment.
Anchor IDL Decoder
Paste a Solana Anchor IDL JSON and browse instructions, accounts, types, and PDA seeds interactively.
CosmWasm Schema Validator
Validate a CosmWasm contract schema (ExecuteMsg, QueryMsg) against sample input payloads.
NFT Metadata Builder
Build NFT metadata JSON for ERC-721, ERC-1155, and Metaplex with attributes, external URLs, and previews.
Token Decimals Calculator
Convert between token raw units and human amounts respecting each token's decimals (USDC 6, ETH 18).
Merkle Tree Generator
Build a Merkle tree from an address / amount list and generate the root plus inclusion proofs for each leaf.
Common use cases
Investigating an unknown contract call on Etherscan
You see a transaction with calldata starting 0x23b872dd… but no ABI attached. Paste the first four bytes into Function Selector Lookup to resolve it (that one is transferFrom(address,address,uint256)). Then feed the full calldata into Calldata Decoder with the resolved signature to extract the from, to, and amount arguments — typically the fastest way to recognize a token theft or a front-running route.
Preparing an airdrop allowlist
You have a CSV of 4,000 addresses and amounts to distribute. Merkle Tree Generator hashes each leaf, builds the tree, and exports the root you commit to the contract plus the inclusion proof for every participant. Before going live, run a handful of the addresses through Ethereum Address Checksum to strip lowercase typos that would invalidate an otherwise valid leaf.
Migrating a user between Cosmos chains
A user reports funds stuck on an IBC transfer and sends you the source denom ibc/27394FB…. Cosmos IBC Denom Parser resolves it back to the originating chain, port, and channel. Then Bech32 Address Converter flips their destination address into the prefix the origin chain expects for the retry.
Previewing an EIP-712 signature flow
Your team is adopting gasless approvals via permit. Assemble the domain, types, and message in EIP-712 Typed Data Builder and copy the canonical JSON to eyeball before plugging it into Wagmi / ethers. If the wallet popup shows fields that do not match, the mismatch is in the types struct or the domain separator — both visible line by line in the preview.
Related guides
How to Generate Secure Passwords in 2026: A Complete Guide
Learn why strong passwords matter and how to generate secure passwords using entropy, length, and complexity. Includes practical tips and free tools.
Understanding Hash Functions: MD5 vs SHA-256 Explained
Deep dive into cryptographic hash functions. Compare MD5 and SHA-256 in terms of security, speed, and real-world applications.
Linux File Permissions and Chmod: A Practical Guide for Developers
Master Linux file permissions and the chmod command. Learn numeric and symbolic notation, common patterns like 755 and 644, and security best practices.
JWT Tokens Explained: A Developer's Guide to JSON Web Tokens
Understand JWT tokens from the inside out. Learn the structure, authentication flow, signing algorithms, and security best practices for JSON Web Tokens.
Frequently asked questions
Do these Web3 tools talk to an RPC or a wallet?
No. Every tool in this category does pure local computation — encoding, decoding, hashing, validating, converting. They never connect to an RPC node, a wallet, or a block explorer, which means you can paste real addresses, private data, and raw transaction payloads without that information leaving the tab. If you need on-chain reads, use a block explorer or your node; use these for the offline half of the workflow.
Which chains are covered?
EVM chains (Ethereum, Polygon, BSC, Arbitrum, Optimism, Base and anything else that speaks EVM), Solana, and Cosmos-based chains (Cosmos Hub, Osmosis, Juno, Neutron, Kaia, XPLA, and any network that uses Bech32 addresses). Bitcoin is supported by the Multi-chain Address Validator. Specialist tools like Anchor IDL Decoder and CosmWasm Schema Validator target framework-specific formats from Solana and Cosmos respectively.
I am new to Solidity — where do I start?
Start with the Wei / Gwei / Ether Converter to get comfortable with unit handling, then paste any transaction hash you are curious about into the Calldata Decoder and the Event Log Decoder to see how call data and logs are structured. From there, ABI Decoder & Encoder and Function Selector Lookup cover the day-to-day of inspecting contracts, and EIP-712 Typed Data Builder lays out the signing workflow most dApps use.
Is Anchor IDL or CosmWasm support useful if I am not on those stacks?
Probably not day-to-day — those two are focused tools for teams building on Solana Anchor and CosmWasm respectively. They are in the catalog because those ecosystems historically lacked a free, no-auth playground to inspect IDLs and validate schemas. If you run audits, indexers, or cross-chain bridges you may reach for them even without shipping on those stacks.
Why a Merkle Tree generator?
Airdrops and allowlists are the most common need. You have a list of addresses (and sometimes amounts), you want a single root to commit on-chain, and each participant needs an inclusion proof. Merkle Tree Generator does both sides: build the tree and export the root, then look up any leaf to get its proof. The proof format is compatible with OpenZeppelin MerkleProof, the most widely deployed verifier on EVM.