ERC-1820 — Pseudo-introspection Registry

Back to Infrastructure & Patterns

ERC-1820: Pseudo-introspection Registry Contract

ERC-1820 deploys a single global registry contract at the deterministic address 0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24 (via Nick's-method singleton deploy). Any contract can register that another address implements an interface for it — setInterfaceImplementer(account, interfaceHash, implementer). ERC-777's tokensReceived hook discovery uses this.

Why It's Needed on Ethereum

ERC-165 only works for contracts that implement the standard themselves. ERC-1820 adds a layer: external delegated implementers, and EOAs that designate another contract to act on their behalf for specific interfaces.

Neo Equivalent

Neo has no global registry contract because the manifest already serves the discovery purpose for the contract's own interfaces, and ContractManagement provides the lookup primitives. For "EOA-style accounts that delegate to another contract", Neo's NEP-30 verify subsumes the use case.

If you genuinely need a key-value style attribute registry, the Neo C# port below shows a minimal version — typically deployed once by an ecosystem and called by participating contracts.

Live on Neo TestNet

Both implementations deployed on Neo N3 TestNet.

Implementation	TestNet Address	Contract Hash
Solidity (neo-solc)	NgiVMV6vo8QHaQEhxMDBMCHdq2Ps5iXQxm	0x02704624…2ad52ee4
Neo C# (nccs)	NaJCEkEXwwsWFHXU791K6Zk3ZpFya5HPk6	0x8f36ff27…99cec59d

Verified: getManager(account) == account (default behavior matches the EIP). docs/standards-mirror/deployments/erc-1820/.

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

contract ERC1820Registry {
    // (account, interfaceHash) -> implementer
    mapping(address => mapping(bytes32 => address)) private _implementer;
    mapping(address => address) private _manager;

    event InterfaceImplementerSet(
        address indexed account, bytes32 indexed interfaceHash, address indexed implementer
    );

    function setInterfaceImplementer(address account, bytes32 interfaceHash, address impl)
        external
    {
        require(getManager(account) == msg.sender, "not manager");
        _implementer[account][interfaceHash] = impl;
        emit InterfaceImplementerSet(account, interfaceHash, impl);
    }

    function getInterfaceImplementer(address account, bytes32 interfaceHash)
        external view returns (address)
    {
        return _implementer[account][interfaceHash];
    }

    function setManager(address account, address newManager) external {
        require(getManager(account) == msg.sender, "not manager");
        _manager[account] = newManager == account ? address(0) : newManager;
    }

    function getManager(address account) public view returns (address) {
        address m = _manager[account];
        return m == address(0) ? account : m;
    }

    function interfaceHash(string calldata name) external pure returns (bytes32) {
        return keccak256(abi.encodePacked(name));
    }
}

using System;
using System.ComponentModel;
using System.Numerics;
using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

[DisplayName("InterfaceRegistry")]
[ContractPermission("*", "*")]
public class InterfaceRegistry : SmartContract
{
    private const byte Prefix_Implementer = 0x01;
    private const byte Prefix_Manager     = 0x02;

    [DisplayName("InterfaceImplementerSet")]
    public static event Action<UInt160, ByteString, UInt160> OnSet;

    public static UInt160 GetImplementer(UInt160 account, ByteString interfaceHash)
        => (UInt160)Storage.Get(Storage.CurrentContext,
                                new byte[] { Prefix_Implementer }
                                    .Concat(account).Concat(interfaceHash));

    public static UInt160 GetManager(UInt160 account)
    {
        var m = (UInt160)Storage.Get(Storage.CurrentContext,
                                     new byte[] { Prefix_Manager }.Concat(account));
        return m ?? account;
    }

    public static void SetImplementer(UInt160 account, ByteString interfaceHash,
                                      UInt160 implementer)
    {
        var manager = GetManager(account);
        if (!Runtime.CheckWitness(manager)) throw new Exception("not manager");

        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Implementer }.Concat(account).Concat(interfaceHash),
                    implementer);
        OnSet(account, interfaceHash, implementer);
    }

    public static void SetManager(UInt160 account, UInt160 newManager)
    {
        if (!Runtime.CheckWitness(GetManager(account))) throw new Exception("not manager");
        if (newManager.Equals(account))
            Storage.Delete(Storage.CurrentContext,
                           new byte[] { Prefix_Manager }.Concat(account));
        else
            Storage.Put(Storage.CurrentContext,
                        new byte[] { Prefix_Manager }.Concat(account), newManager);
    }

    public static ByteString InterfaceHash(string name)
        => CryptoLib.Sha256((ByteString)System.Text.Encoding.UTF8.GetBytes(name));
}

Why Most Contracts Won't Need This

The big ERC-1820 use case — delegating ERC-777 token reception to another contract — is solved on Neo by onNEP17Payment: every NEP-17 recipient can implement the hook directly, and the manifest advertises NEP-27 compliance. No registry lookup needed.