Multi-Version ABI Compatibility Checker

WHAT IT DOES

Multi-Version ABI Compatibility Checker compares two different contract ABIs against the actual bytecode of a deployed contract on any EVM chain. It extracts all function selectors (the first 4 bytes of the Keccak-256 hash of each function signature) from both ABIs and cross-references them with the function selectors present in the contract's runtime bytecode. The tool shows you exactly which functions from each ABI are actually implemented on-chain, which signatures match between the two versions, and which functions exist in one ABI but not the other. It highlights selector collisions, signature mismatches where the same selector resolves to different function names, and missing functions that are declared in an ABI but absent from the bytecode. This is essential when you have multiple versions of a contract interface, when you're migrating between compiler versions, or when you suspect an ABI does not match the deployed code. The tool also detects functions that are present in the bytecode but not declared in either ABI, helping you uncover undocumented methods or maliciously added functions.

HOW TO USE

Connect your wallet to select the target EVM network. Enter the contract address you want to verify. Paste your first ABI as a JSON array into the ABI Version A textarea, and your second ABI into the Version B textarea. Click "Check Compatibility". The tool fetches the runtime bytecode from the chain, scans it for all function selectors (looking for PUSH4 instructions followed by 4 bytes), and then builds a compatibility matrix. Results are displayed as a color-coded table showing each selector, the corresponding signature from each ABI, whether that selector exists on-chain, and a status label indicating if the signature matches, conflicts, is missing, or appears as an extra entry. Functions that match across both ABIs and are present on-chain are marked in green. Partial matches where only one ABI contains a function that exists on-chain are shown in amber. Functions declared in an ABI but not found in the bytecode are marked in red. The tool also shows aggregate statistics including total functions, matched signatures, partial matches, missing functions, and extra ABI entries not found on-chain.

THE REAL MECHANISM

The tool does not rely on source code, compilation artifacts, or a database of known signatures. Instead, it performs a direct binary analysis of the contract's runtime bytecode. It scans the bytecode for the PUSH4 opcode (0x63) followed by the next 4 bytes, which the Solidity compiler emits for every public and external function selector embedded in the contract's dispatch table. This method captures all callable functions regardless of whether they are documented in an ABI. The tool then computes the Keccak-256 hash of each function signature from both ABIs using ethers.utils.keccak256(ethers.utils.toUtf8Bytes(signature)) and takes the first 4 bytes. It compares these selectors against the bytecode-extracted set. For each selector found in either ABI, the tool checks if it exists on-chain and whether the signature strings from ABI A and ABI B are identical when both declare the same selector. This reveals silent breaking changes: two functions with the same name and parameter types but different internal behavior will have identical selectors, and the tool cannot distinguish them semantically, but it will flag that the signatures match structurally. The tool also handles overloaded functions by using the full signature including parameter types, ensuring that overloads resolve to distinct selectors.

WHAT IT CANNOT SEE

This tool cannot detect semantic differences in behavior between two functions that share an identical signature. A function named "transfer(address,uint256)" with the same parameters will always produce the same selector, even if one version implements a pausable transfer and the other does not. It cannot verify that the bytecode was actually deployed from the source code you expect, only that the selectors present in the bytecode match those declared in the ABI. The tool does not check event signatures, error types, or custom errors. It does not detect proxy patterns—if you point it at a proxy contract address, it will analyze the proxy's minimal bytecode rather than the implementation contract's bytecode. It cannot detect upgradeable contracts or determine if the contract follows a specific standard like ERC-20 or ERC-721 beyond what is declared in the ABI. The tool does not verify constructor arguments or initialization code—it only analyzes the runtime bytecode after deployment. It cannot detect functions that are only reachable via delegatecall or selfdestruct. The tool does not verify that the bytecode is verified on Etherscan or any other block explorer.

PLEASE NOTE

Multi-Version ABI Compatibility Checker works exclusively with Ethereum Virtual Machine (EVM) compatible chains including Ethereum, Goerli, Sepolia, Polygon, BSC, Arbitrum, Optimism, Avalanche, and others. The tool requires the contract address to be valid on the selected network and for the node to support eth_getCode. It reads bytecode only and does not send any transactions or modifications to the blockchain. All processing occurs client-side in your browser; no data is sent to any external server. The tool is free to use and does not require authentication.