ERC-165 — Interface Detection

Back to Infrastructure & Patterns

ERC-165: Standard Interface Detection

ERC-165 lets a contract advertise which interfaces it implements via a 4-byte ID derived from the XOR of function selectors. Wallets call supportsInterface(bytes4) to detect ERC-721, ERC-2981, ERC-1155 compliance.

Why It's Needed on Ethereum

Ethereum has no concept of contract metadata. The bytecode just is the bytecode. ERC-165 invented a runtime convention: every interface has an ID, and contracts must implement a registry function. Detection costs at least one external call.

Neo Equivalent: Manifest supportedstandards

Neo contracts deploy with a manifest — a JSON document committed alongside the NEF bytecode. The manifest includes a supportedstandards array that wallets and explorers read directly. No runtime call. No gas. The compiler populates it automatically based on method signature analysis.

Live on Neo TestNet

Both implementations are deployed on Neo N3 TestNet (network magic 894710606).

Implementation	Contract Hash	Deploy Tx
Solidity (neo-solc)	0x2b5db552d1c23a43f51a0ea50765e4a1a7a051e6	(reused — see 0x2b5db552d1c23a43f51a0ea50765e4a1a7a051e6)
Neo C# (nccs)	0xa400b6cb20159fb3140798401c41edcb06e00f49	(reused — see 0xa400b6cb20159fb3140798401c41edcb06e00f49)

Cross-implementation invocations match on supportsInterface. Source pairs under docs/standards-mirror/deployments/erc-165/.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IERC165 {
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

abstract contract ERC165 is IERC165 {
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

contract MyContract is ERC165 {
    bytes4 private constant _INTERFACE_ID_MY = 0xdeadbeef;

    function supportsInterface(bytes4 id) public pure override returns (bool) {
        return id == _INTERFACE_ID_MY
            || id == 0x01ffc9a7;  // ERC-165 itself
    }
}

contract Detector {
    function isERC721(address target) external view returns (bool) {
        try IERC165(target).supportsInterface(0x80ac58cd) returns (bool ok) {
            return ok;
        } catch {
            return false;
        }
    }
}

using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;

namespace R3E.Examples;

[DisplayName("DemoToken")]
[SupportedStandards(NepStandard.Nep17, NepStandard.Nep27)]   // ← ERC-165 equivalent in one attribute
[ContractPermission("*", "*")]
public class DemoToken : SmartContract { /* ... */ }

/// <summary>Detect compliance from another contract — zero external calls into the target.</summary>
public static class StandardsDetector
{
    public static bool IsNep17(UInt160 candidate)
    {
        var contract = ContractManagement.GetContract(candidate);
        if (contract == null) return false;
        foreach (var std in contract.Manifest.SupportedStandards)
            if (std == "NEP-17") return true;
        return false;
    }

    public static bool IsNep11(UInt160 candidate)
    {
        var contract = ContractManagement.GetContract(candidate);
        if (contract == null) return false;
        foreach (var std in contract.Manifest.SupportedStandards)
            if (std == "NEP-11") return true;
        return false;
    }
}

ContractManagement.GetContract reads from the contract state ledger directly without invoking any user code on the target. There is no re-entrancy surface and no opportunity for the target contract to lie or revert.