ERC-2535 — Diamond Standard

Back to Infrastructure & Patterns

ERC-2535: Diamond Multi-Facet Proxy

ERC-2535 ("Diamonds") extends ERC-1967 to allow a single proxy to dispatch calls across many implementation contracts ("facets"). Each function selector is mapped to exactly one facet. Diamonds let you upgrade individual functions without reimplementing the whole contract, work around Ethereum's 24KB contract size limit by spreading code across facets, and cleanly separate concerns.

IDiamondCut and IDiamondLoupe

function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata)
    external;
function facetAddress(bytes4 _functionSelector) external view returns (address);
function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory);

Neo Equivalent

Neo contracts have no 24 KB size limit (NEF max is 1 MB) so diamonds aren't needed purely for size. But the modular-upgrade-per-function pattern is still useful and implementable on Neo via a small dispatcher contract that routes by method name to the correct facet contract.

Live on Neo TestNet

Both implementations deployed on Neo N3 TestNet.

Implementation	TestNet Address	Contract Hash
Solidity (neo-solc)	NMtzwNXhZGetcyPmotYvf4ALMEJD1xjGSb	0x26b6f333…cf79f527
Neo C# (nccs)	NXNKvkkpyx9Z5KYCAS6JrH6GDPEPhwvZsE	0x1b3c602c…34c5bdcf

Verified: ownership claim and method-router state. The Neo port avoids delegatecall (which doesn't exist in NeoVM) — instead, Dispatch(method, args) looks up the facet contract and invokes it via Contract.Call(facet, method, ...). Cleaner audit surface than the EVM diamond pattern. docs/standards-mirror/deployments/erc-2535/.

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

interface IDiamondCut {
    enum FacetCutAction { Add, Replace, Remove }
    struct FacetCut {
        address facetAddress;
        FacetCutAction action;
        bytes4[] functionSelectors;
    }
    function diamondCut(FacetCut[] calldata _cut, address _init, bytes calldata _calldata) external;
}

contract Diamond {
    bytes32 constant DIAMOND_STORAGE = keccak256("diamond.storage");

    struct DiamondStorage {
        mapping(bytes4 => address) facetAddress;
        mapping(bytes4 => uint256) facetSelectorIndex;
        mapping(address => bytes4[]) facetSelectors;
    }

    function ds() internal pure returns (DiamondStorage storage s) {
        bytes32 slot = DIAMOND_STORAGE;
        assembly { s.slot := slot }
    }

    fallback() external payable {
        address facet = ds().facetAddress[msg.sig];
        require(facet != address(0), "no facet");
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }
}

using System;
using System.ComponentModel;
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("Diamond")]
[ContractPermission("*", "*")]
public class Diamond : SmartContract
{
    private const byte Prefix_FacetByMethod = 0x01;
    private static readonly byte[] OwnerKey = { 0xff };

    [DisplayName("FacetCut")]
    public static event Action<string, UInt160> OnFacetCut;

    /// <summary>Map a method name to a facet contract.</summary>
    public static void AddFacet(string method, UInt160 facet)
    {
        var owner = (UInt160)Storage.Get(Storage.CurrentContext, OwnerKey);
        if (!Runtime.CheckWitness(owner)) throw new Exception("owner only");
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_FacetByMethod }
                        .Concat((ByteString)System.Text.Encoding.UTF8.GetBytes(method)),
                    facet);
        OnFacetCut(method, facet);
    }

    public static void RemoveFacet(string method)
    {
        var owner = (UInt160)Storage.Get(Storage.CurrentContext, OwnerKey);
        if (!Runtime.CheckWitness(owner)) throw new Exception("owner only");
        Storage.Delete(Storage.CurrentContext,
                       new byte[] { Prefix_FacetByMethod }
                           .Concat((ByteString)System.Text.Encoding.UTF8.GetBytes(method)));
    }

    public static UInt160 FacetAddress(string method)
        => (UInt160)Storage.Get(Storage.CurrentContext,
            new byte[] { Prefix_FacetByMethod }
                .Concat((ByteString)System.Text.Encoding.UTF8.GetBytes(method)));

    /// <summary>
    /// Dispatch — clients invoke "Dispatch" with the target method name, and
    /// the diamond routes to the appropriate facet contract.
    /// </summary>
    public static object Dispatch(string method, object[] args)
    {
        var facet = FacetAddress(method);
        if (facet == null) throw new Exception("no facet for method");
        return Contract.Call(facet, method, CallFlags.All, args);
    }

    public static void _deploy(object data, bool update)
    {
        if (update) return;
        Storage.Put(Storage.CurrentContext, OwnerKey, (UInt160)data);
    }
}

Differences from EVM Diamonds

• No delegatecall: facets don't share storage with the diamond. If a facet needs persistent state, it owns its own storage. This is actually safer — facets can't accidentally trample each other.
• Method-name routing instead of 4-byte selector routing — readable and easier to debug.
• No size pressure: Neo's NEF size limit (1 MB) is rarely the reason to choose a diamond. Use modular dispatch when you genuinely want hot-swappable per-method upgrades.