ERC165

ERC165 is an Ethereum Request for Comments (ERC) standard that provides a mechanism for a smart contract to publish and detect which interfaces it implements. The core function, supportsInterface, allows other contracts or off-chain systems to query whether a specific interface identifier (a 4-byte function selector) is supported. This creates a foundational layer for type introspection on the blockchain, allowing for the development of more flexible and interoperable systems by programmatically verifying a contract's capabilities before interacting with it.

The standard is critical for the broader Ethereum ecosystem because it underpins many other major standards. For instance, ERC721 (Non-Fungible Tokens) and ERC1155 (Multi-Token) mandates the implementation of ERC165. This allows marketplaces, wallets, and other services to reliably detect if a contract is an NFT contract and which specific features (like metadata or enumeration) it supports. Without this standard, applications would need to rely on error-prone methods like trial-and-error calls or off-chain registries to determine a contract's functions.

Technically, an interface identifier is calculated as the XOR of all function selectors in the interface. A contract declares its support by returning true when its supportsInterface(bytes4 interfaceId) function is called with the correct ID. The standard also defines a mechanism for registering interfaces in a global EIP-165 registry, although direct contract implementation is more common. This design ensures the check is both gas-efficient and secure, as it's a simple, read-only call that cannot be spoofed without breaking the contract's own functionality.

For developers, implementing ERC165 involves overriding the supportsInterface function to check against a hardcoded set of supported interface IDs, often using a mapping or a series of if statements. A common practice is to combine IDs using the bitwise OR operator (|) for interfaces that are composed of others. This standard is a prerequisite for creating composable and upgradeable contracts, as it allows proxy contracts or managers to verify the compatibility of new logic implementations before an upgrade is executed.

The widespread adoption of ERC165 has made it a cornerstone of Ethereum's infrastructure. It enables a contract-first discovery paradigm where dApps can dynamically adapt to the contracts they interact with. This is essential for the evolving DeFi and NFT landscapes, where new token standards and financial primitives constantly emerge. By providing a reliable, on-chain method for interface detection, ERC165 reduces integration complexity and fosters a more connected and automated smart contract ecosystem.

ERC165 is an Ethereum Request for Comments standard that defines a method for smart contracts to publish and detect the interfaces they implement. At its core, a contract compliant with ERC165 must implement a function called supportsInterface(bytes4 interfaceId) that returns true if the contract implements the interface identified by the 4-byte interfaceId, and false otherwise. This function acts as a standardized query mechanism, allowing other contracts and off-chain systems to programmatically verify a contract's capabilities before interacting with it, preventing runtime errors and failed transactions.

The standard operates using interface identifiers, which are calculated as the XOR (exclusive OR) of all function selectors within an interface. A function selector is the first four bytes of the Keccak-256 hash of a function's signature (e.g., balanceOf(address)). For example, the interfaceId for ERC721 is 0x80ac58cd, derived from hashing its core functions. When a contract's supportsInterface is called with 0x80ac58cd, it should return true only if it implements the full ERC721 specification. This precise, cryptographic method ensures unambiguous identification.

Implementation involves two key steps. First, a contract must declare its support for ERC165 itself by returning true for the ERC165 interface ID (0x01ffc9a7). Second, it must override the supportsInterface function to check both the ERC165 ID and any other interface IDs it supports, typically using a mapping or a series of if statements. For instance, an ERC721 contract would return true for 0x01ffc9a7 (ERC165) and 0x80ac58cd (ERC721). This layered check allows a caller to first confirm a contract uses ERC165, then query for specific functionality.

The primary use case for ERC165 is enabling safe composability in the Ethereum ecosystem. Wallets and marketplaces use it to detect if a contract is an ERC721 NFT or an ERC1155 multi-token before attempting to display assets. Upgradable proxy patterns use it to verify new implementation contracts support required interfaces. It also prevents the common error of sending tokens to a contract that cannot handle them, as the receiving contract can reject interactions if it does not supportInterface for the token standard. This creates a more robust and predictable environment for decentralized applications.

While essential, developers must be aware of nuances. Manually calculating and hardcoding interface IDs is error-prone; using helper functions from libraries like OpenZeppelin is recommended. The standard also defines that supportsInterface must return false for any unverified interfaceId, not throw an error. Furthermore, ERC165 does not validate the correctness of an implementation, only its declared adherence to an interface's function signatures. It is a foundational standard upon which more complex interoperability, such as ERC-3668's CCIP Read, is built for cross-chain and off-chain data retrieval.

The following Solidity code demonstrates a minimal implementation of ERC165 for a hypothetical ERC721 token contract. The core function is supportsInterface(bytes4 interfaceId), which returns true if the contract implements the interface queried. The example shows how to calculate and store the interface identifier for the ERC721 interface (0x80ac58cd) and the ERC165 interface itself (0x01ffc9a7) in the contract's constructor, enabling other contracts to programmatically discover its capabilities.

This pattern is fundamental for composable smart contract systems. By implementing ERC165, a contract declares its adherence to a known standard, allowing wallets, marketplaces, and other contracts to interact with it safely and predictably. For instance, a decentralized exchange can query an unknown token contract to verify it is a valid ERC20 or ERC721 before attempting to list it, preventing runtime errors and enhancing security through runtime interface checking.

Developers should note that the interface ID is not the contract's ABI or bytecode hash; it is a 4-byte selector derived from the XOR of all function selectors in the interface. The example uses type(IERC721).interfaceId for clarity, which Solidity calculates automatically. For custom interfaces, developers must compute this value manually. Proper implementation requires overriding supportsInterface to check for ERC165's own interface ID and any other supported interfaces, typically using a private mapping or inline logic.