ERC-5484 — Consensual Soulbound

Back to Token Standards

ERC-5484: Consensual Soulbound Tokens

ERC-5484 extends the soulbound concept with explicit consent semantics for who can burn the token: the issuer, the recipient, both, or neither. This addresses real use cases: a recipient should be able to burn an unwanted credential, an issuer should be able to revoke a fraudulent one, and some tokens (e.g. blacklist marks) should be permanent.

BurnAuth Enum

Value	Who can burn
0 IssuerOnly	Only the contract issuer
1 OwnerOnly	Only the token holder
2 Both	Either party
3 Neither	Permanent — neither can destroy it

Required Method

function burnAuth(uint256 tokenId) external view returns (BurnAuth);
event Issued(address indexed from, address indexed to, uint256 indexed tokenId, BurnAuth burnAuth);

Neo Equivalent: Direct Port

Standard Neo C# port — store per-token burnAuth and check it in the burn function.

Live on Neo TestNet

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

Implementation	Contract Hash	Deploy Tx
Solidity (neo-solc)	0x8a9e1835270c95ddf5250ee84a1d4714552cb951	0xa440db2d…f4246a
Neo C# (nccs)	0x02317b7192e3d91ba1739ae2a9f5fdcd44bf2dac	0xebc7d7f7…d9432c

Cross-implementation invocations match on claimIssuer, tokenCount, getIssuer. Source pairs under docs/standards-mirror/deployments/erc-5484/.

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

abstract contract ConsensualSBT {
    enum BurnAuth { IssuerOnly, OwnerOnly, Both, Neither }

    address public issuer;
    mapping(uint256 => address)  private _owner;
    mapping(uint256 => BurnAuth) private _burnAuth;

    event Issued(address indexed from, address indexed to,
                 uint256 indexed tokenId, BurnAuth burnAuth);

    constructor() { issuer = msg.sender; }

    function burnAuth(uint256 tokenId) external view returns (BurnAuth) {
        return _burnAuth[tokenId];
    }

    function issue(address to, uint256 tokenId, BurnAuth auth) external {
        require(msg.sender == issuer, "not issuer");
        _owner[tokenId] = to;
        _burnAuth[tokenId] = auth;
        emit Issued(issuer, to, tokenId, auth);
    }

    function burn(uint256 tokenId) external {
        BurnAuth auth = _burnAuth[tokenId];
        if (auth == BurnAuth.Neither)        revert("permanent");
        if (auth == BurnAuth.IssuerOnly)     require(msg.sender == issuer, "issuer only");
        if (auth == BurnAuth.OwnerOnly)      require(msg.sender == _owner[tokenId], "owner only");
        if (auth == BurnAuth.Both)           require(msg.sender == issuer
                                                  || msg.sender == _owner[tokenId], "issuer or owner only");
        delete _owner[tokenId];
        delete _burnAuth[tokenId];
    }
}

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;

public enum BurnAuth : byte { IssuerOnly = 0, OwnerOnly = 1, Both = 2, Neither = 3 }

[DisplayName("ConsensualSBT")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep11)]
public class ConsensualSBT : SmartContract
{
    private const byte Prefix_Owner    = 0x01;
    private const byte Prefix_BurnAuth = 0x02;
    private static readonly byte[] IssuerKey = { 0xFE };

    [DisplayName("Issued")]
    public static event Action<UInt160, UInt160, ByteString, byte> OnIssued;
    [DisplayName("Burned")]
    public static event Action<ByteString> OnBurned;

    public static byte BurnAuthOf(ByteString tokenId)
    {
        var raw = Storage.Get(Storage.CurrentContext,
                              new byte[] { Prefix_BurnAuth }.Concat(tokenId));
        if (raw == null) throw new Exception("nonexistent");
        return (byte)(BigInteger)raw;
    }

    public static void Issue(UInt160 to, ByteString tokenId, byte auth)
    {
        var issuer = (UInt160)Storage.Get(Storage.CurrentContext, IssuerKey);
        if (!Runtime.CheckWitness(issuer)) throw new Exception("issuer only");
        if (auth > 3) throw new Exception("invalid auth");
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Owner }.Concat(tokenId), to);
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_BurnAuth }.Concat(tokenId), auth);
        OnIssued(issuer, to, tokenId, auth);
    }

    public static void Burn(ByteString tokenId)
    {
        var auth   = (BurnAuth)BurnAuthOf(tokenId);
        var owner  = (UInt160)Storage.Get(Storage.CurrentContext,
                                          new byte[] { Prefix_Owner }.Concat(tokenId));
        var issuer = (UInt160)Storage.Get(Storage.CurrentContext, IssuerKey);

        bool canBurn = auth switch
        {
            BurnAuth.Neither    => false,
            BurnAuth.IssuerOnly => Runtime.CheckWitness(issuer),
            BurnAuth.OwnerOnly  => Runtime.CheckWitness(owner),
            BurnAuth.Both       => Runtime.CheckWitness(issuer)
                                || Runtime.CheckWitness(owner),
            _ => false
        };
        if (!canBurn) throw new Exception("not authorized to burn");

        Storage.Delete(Storage.CurrentContext,
                       new byte[] { Prefix_Owner }.Concat(tokenId));
        Storage.Delete(Storage.CurrentContext,
                       new byte[] { Prefix_BurnAuth }.Concat(tokenId));
        OnBurned(tokenId);
    }

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