ERC-1056 — Lightweight Identity

Back to Infrastructure & Patterns

ERC-1056: Ethereum Lightweight Identity (DID)

ERC-1056 (also known as ETHR-DID) is a registry contract that lets any Ethereum address attach delegate keys, off-chain attribute proofs, and identity owners without deploying a per-identity contract. Used by uPort, Veramo, and many self-sovereign identity systems.

Required Methods (Highlights)

function identityOwner(address identity) external view returns (address);
function changeOwner(address identity, address newOwner) external;
function addDelegate(address identity, bytes32 delegateType, address delegate, uint validity) external;
function setAttribute(address identity, bytes32 name, bytes value, uint validity) external;

Neo Equivalent: Direct Port

The Neo port is a single registry contract that any account can use. Like the Solidity version, it's pay-per-use: the registry charges no fee beyond the storage cost of the identity records, and the witness model handles authorisation.

Live on Neo TestNet

Both implementations deployed on Neo N3 TestNet.

Implementation	TestNet Address	Contract Hash
Solidity (neo-solc)	NViDh6CD7QV2Q6V31qAcNkyDeC3UmLAi8z	0xdd6d4a48…2ef41f50
Neo C# (nccs)	Nb2QQRhWzy7fgipLUyAZkivapVWa8YWA1F	0xd13806f6…b74c1b30

Verified: default identityOwner(account) == account matches the EIP. addDelegate / validDelegate flows are implemented; tested locally with the Runtime.Time-based expiry check. docs/standards-mirror/deployments/erc-1056/.

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

contract EthereumDIDRegistry {
    mapping(address => address) public owners;
    mapping(address => mapping(bytes32 => mapping(address => uint))) public delegates;
    mapping(address => uint) public changed;

    event DIDOwnerChanged(address indexed identity, address owner, uint previousChange);
    event DIDDelegateChanged(
        address indexed identity, bytes32 delegateType,
        address delegate, uint validTo, uint previousChange
    );

    function identityOwner(address id) public view returns (address) {
        address o = owners[id];
        return o == address(0) ? id : o;
    }

    function changeOwner(address id, address newOwner) external {
        require(msg.sender == identityOwner(id), "not owner");
        owners[id] = newOwner;
        emit DIDOwnerChanged(id, newOwner, changed[id]);
        changed[id] = block.number;
    }

    function addDelegate(address id, bytes32 delegateType, address delegate, uint validity)
        external
    {
        require(msg.sender == identityOwner(id), "not owner");
        delegates[id][delegateType][delegate] = block.timestamp + validity;
        emit DIDDelegateChanged(id, delegateType, delegate, block.timestamp + validity, changed[id]);
        changed[id] = block.number;
    }

    function validDelegate(address id, bytes32 delegateType, address delegate)
        external view returns (bool)
    {
        return delegates[id][delegateType][delegate] > block.timestamp;
    }
}

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("DIDRegistry")]
[ContractPermission("*", "*")]
public class DIDRegistry : SmartContract
{
    private const byte Prefix_Owner    = 0x01;
    private const byte Prefix_Delegate = 0x02;  // identity+type+delegate -> validTo
    private const byte Prefix_Changed  = 0x03;
    private const byte Prefix_Attr     = 0x04;  // identity+name -> (value, validTo)

    [DisplayName("DIDOwnerChanged")]
    public static event Action<UInt160, UInt160, BigInteger> OnOwnerChanged;
    [DisplayName("DIDDelegateChanged")]
    public static event Action<UInt160, ByteString, UInt160, BigInteger, BigInteger> OnDelegateChanged;

    public static UInt160 IdentityOwner(UInt160 identity)
    {
        var owner = (UInt160)Storage.Get(Storage.CurrentContext,
                                         new byte[] { Prefix_Owner }.Concat(identity));
        return owner ?? identity;
    }

    public static void ChangeOwner(UInt160 identity, UInt160 newOwner)
    {
        var owner = IdentityOwner(identity);
        if (!Runtime.CheckWitness(owner)) throw new Exception("not owner");

        var prevChange = Changed(identity);
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Owner }.Concat(identity), newOwner);
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Changed }.Concat(identity), Ledger.CurrentIndex);
        OnOwnerChanged(identity, newOwner, prevChange);
    }

    public static void AddDelegate(UInt160 identity, ByteString delegateType,
                                   UInt160 delegateAddr, BigInteger validity)
    {
        var owner = IdentityOwner(identity);
        if (!Runtime.CheckWitness(owner)) throw new Exception("not owner");

        var validTo = Runtime.Time / 1000 + validity;
        var prevChange = Changed(identity);
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Delegate }.Concat(identity)
                        .Concat(delegateType).Concat(delegateAddr),
                    validTo);
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Changed }.Concat(identity), Ledger.CurrentIndex);
        OnDelegateChanged(identity, delegateType, delegateAddr, validTo, prevChange);
    }

    public static bool ValidDelegate(UInt160 identity, ByteString delegateType, UInt160 delegateAddr)
    {
        var key = new byte[] { Prefix_Delegate }.Concat(identity)
                     .Concat(delegateType).Concat(delegateAddr);
        var validTo = (BigInteger)(Storage.Get(Storage.CurrentContext, key) ?? ByteString.Empty);
        return validTo > Runtime.Time / 1000;
    }

    private static BigInteger Changed(UInt160 identity)
        => (BigInteger)(Storage.Get(Storage.CurrentContext,
            new byte[] { Prefix_Changed }.Concat(identity)) ?? ByteString.Empty);
}