ERC-5773 — Context-Dependent Multi-Asset Tokens

Back to Token Standards

ERC-5773: Context-Dependent Multi-Asset NFTs

ERC-5773 lets a single NFT carry multiple asset representations — e.g. a 3D model + a 2D image + an animation + raw metadata — each selectable by viewer context. A wallet rendering on mobile picks the 2D image; a VR headset picks the 3D model; an indexer picks the raw metadata. The contract stores all assets and exposes a priority list the viewer consults to pick the right one.

Used by:

• 3D NFTs that need both a static preview and a full mesh.
• Animated NFTs with both a still cover and the animation.
• Cross-platform game items with renders for each engine.
• AR / VR collectibles with multiple resolution / format variants.

Required Interface (abridged)

interface IERC5773 {
    event AssetSet(uint64 assetId);
    event AssetAddedToTokens(uint256[] tokenIds, uint64 assetId, uint64 replacesAssetWithId);
    event AssetAccepted(uint256 indexed tokenId, uint64 indexed assetId, uint64 replacesAssetWithId);
    event AssetPrioritySet(uint256 indexed tokenId);

    function getActiveAssets(uint256 tokenId)             external view returns (uint64[] memory);
    function getPendingAssets(uint256 tokenId)            external view returns (uint64[] memory);
    function getActiveAssetPriorities(uint256 tokenId)    external view returns (uint16[] memory);
    function getAssetReplacements(uint256 tokenId, uint64 newAssetId) external view returns (uint64);
    function getAssetMetadata(uint256 tokenId, uint64 assetId)        external view returns (string memory);

    function acceptAsset(uint256 tokenId, uint256 index, uint64 assetId) external;
    function rejectAsset(uint256 tokenId, uint256 index, uint64 assetId) external;
    function setPriority(uint256 tokenId, uint16[] calldata priorities) external;
}

Issuer can propose a new asset (added to pending list); the token holder accepts it (moves to active list) or rejects it. Once active, the holder can re-prioritise the asset list. This propose-accept flow prevents unwanted assets being forced onto a token.

Neo Equivalent: NEP-11 + Per-Token Asset List + Priority

The Neo port stores per-token asset arrays plus priority indices:

public static BigInteger[] GetActiveAssets(ByteString tokenId)
{
    var raw = Storage.Get(Storage.CurrentContext, ActiveAssetsKey(tokenId));
    return raw is null ? new BigInteger[0] : (BigInteger[])StdLib.Deserialize((ByteString)raw);
}

public static void AcceptAsset(ByteString tokenId, BigInteger pendingIndex, BigInteger assetId)
{
    if (!Runtime.CheckWitness(OwnerOf(tokenId))) throw new Exception("NEP11:NotOwner");
    var pending = GetPendingAssets(tokenId);
    if (pendingIndex >= pending.Length || pending[pendingIndex] != assetId)
        throw new Exception("NEP11:WrongAsset");
    // Remove from pending, append to active.
    var active = GetActiveAssets(tokenId);
    var newActive = new BigInteger[active.Length + 1];
    for (var i = 0; i < active.Length; i++) newActive[i] = active[i];
    newActive[active.Length] = assetId;
    SetActiveAssets(tokenId, newActive);
    SetPendingAssets(tokenId, RemoveAt(pending, pendingIndex));
    OnAssetAccepted(tokenId, assetId, 0);
}

ERC-5773 (Ethereum)	Neo Equivalent	Notes
Asset registry (asset id → metadata URI)	Map<uint64, string> in storage	Issuer-managed metadata catalog
Pending vs active asset lists	Two separate storage prefixes per tokenId	Same propose-accept flow
acceptAsset / rejectAsset	AcceptAsset / RejectAsset owner-witness-checked
setPriority(uint16[])	SetPriority(uint16[]) reorders the active list
getActiveAssetPriorities	View returning the active list in priority order
getAssetMetadata(tokenId, assetId)	View returning the asset's metadata URI

Composition

• ERC-7160 — multi-metadata. ERC-5773 is more general (multiple typed assets vs a list of URI variants). Use 7160 for simple metadata versioning, 5773 when assets have distinct contexts.
• ERC-6220 — composable equippable parts (not yet mirrored). ERC-5773 is the asset layer; 6220 builds composable rigs on top.
• ERC-6059 — nestable NFTs. Often paired so child NFTs can be assets of a parent.
• ERC-4906 — metadata update event. Emit on asset accept / priority change so wallets refresh.

Migration Notes

For Solidity collections using ERC-5773 (typically RMRK Modular NFTs):

1. Store the asset registry as Map<int, string> for (assetId → metadataURI).
2. Per-token active + pending arrays as serialised storage entries.
3. Issuer-side AddAsset to create a pending asset; holder-side Accept / Reject to manage their token's active set.
4. SetPriority lets the holder reorder for default rendering.

The Neo port is verbose but mechanical — the propose-accept flow and the storage layout are the only design choices, both already settled by the Solidity reference.

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

contract ERC5773 {
    mapping(uint64 => string) public assetMetadata;
    mapping(uint256 => uint64[]) internal _activeAssets;
    mapping(uint256 => uint64[]) internal _pendingAssets;
    mapping(uint256 => uint16[]) internal _activeAssetPriorities;

    event AssetAccepted(uint256 indexed tokenId, uint64 indexed assetId, uint64 replacesAssetWithId);

    function addAsset(uint64 assetId, string calldata metadataURI) external {
        assetMetadata[assetId] = metadataURI;
    }

    function proposeAssetForToken(uint256 tokenId, uint64 assetId) external {
        // Issuer-only; appends to pending list.
        _pendingAssets[tokenId].push(assetId);
    }

    function acceptAsset(uint256 tokenId, uint256 index, uint64 assetId) external {
        require(_pendingAssets[tokenId][index] == assetId, "wrong asset");
        // Remove from pending; append to active.
        _activeAssets[tokenId].push(assetId);
        // ... compact pending array ...
        emit AssetAccepted(tokenId, assetId, 0);
    }
}

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("MultiAssetNFT")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep11)]
public class MultiAssetNFT : Nep11Token<TokenState>
{
    public override string Symbol => "MASS";

    private const byte Prefix_AssetMeta   = 0xE0;
    private const byte Prefix_Active      = 0xE1;
    private const byte Prefix_Pending     = 0xE2;
    private const byte Prefix_Priority    = 0xE3;
    private const byte Prefix_Issuer      = 0xff;

    [DisplayName("AssetAccepted")]
    public static event Action<ByteString, BigInteger, BigInteger> OnAssetAccepted;

    public static void AddAsset(BigInteger assetId, string metadataURI)
    {
        if (!Runtime.CheckWitness(GetIssuer())) throw new Exception("NEP11:NotIssuer");
        Storage.Put(Storage.CurrentContext, AssetMetaKey(assetId), metadataURI);
    }

    public static void ProposeAssetForToken(ByteString tokenId, BigInteger assetId)
    {
        if (!Runtime.CheckWitness(GetIssuer())) throw new Exception("NEP11:NotIssuer");
        var pending = GetPendingAssets(tokenId);
        var newPending = new BigInteger[pending.Length + 1];
        for (var i = 0; i < pending.Length; i++) newPending[i] = pending[i];
        newPending[pending.Length] = assetId;
        SetPendingAssets(tokenId, newPending);
    }

    public static void AcceptAsset(ByteString tokenId, BigInteger pendingIndex, BigInteger assetId)
    {
        if (!Runtime.CheckWitness(OwnerOf(tokenId))) throw new Exception("NEP11:NotOwner");
        var pending = GetPendingAssets(tokenId);
        if (pendingIndex >= pending.Length || pending[(int)pendingIndex] != assetId)
            throw new Exception("NEP11:WrongAsset");

        var active = GetActiveAssets(tokenId);
        var newActive = new BigInteger[active.Length + 1];
        for (var i = 0; i < active.Length; i++) newActive[i] = active[i];
        newActive[active.Length] = assetId;
        SetActiveAssets(tokenId, newActive);

        var newPending = new BigInteger[pending.Length - 1];
        var p = 0;
        for (var i = 0; i < pending.Length; i++)
            if (i != (int)pendingIndex) newPending[p++] = pending[i];
        SetPendingAssets(tokenId, newPending);

        OnAssetAccepted(tokenId, assetId, 0);
    }

    public static BigInteger[] GetActiveAssets(ByteString tokenId)
    {
        var raw = Storage.Get(Storage.CurrentContext, ActiveKey(tokenId));
        return raw is null ? new BigInteger[0] : (BigInteger[])StdLib.Deserialize((ByteString)raw);
    }
    public static BigInteger[] GetPendingAssets(ByteString tokenId)
    {
        var raw = Storage.Get(Storage.CurrentContext, PendingKey(tokenId));
        return raw is null ? new BigInteger[0] : (BigInteger[])StdLib.Deserialize((ByteString)raw);
    }
    public static string GetAssetMetadata(BigInteger assetId)
        => (string)Storage.Get(Storage.CurrentContext, AssetMetaKey(assetId));

    private static void SetActiveAssets(ByteString tokenId, BigInteger[] arr)
        => Storage.Put(Storage.CurrentContext, ActiveKey(tokenId), StdLib.Serialize(arr));
    private static void SetPendingAssets(ByteString tokenId, BigInteger[] arr)
        => Storage.Put(Storage.CurrentContext, PendingKey(tokenId), StdLib.Serialize(arr));

    private static byte[] AssetMetaKey(BigInteger id)
        => new byte[] { Prefix_AssetMeta }.Concat((ByteString)(byte[])id.ToByteArray());
    private static byte[] ActiveKey(ByteString tokenId)   => new byte[] { Prefix_Active   }.Concat(tokenId);
    private static byte[] PendingKey(ByteString tokenId)  => new byte[] { Prefix_Pending  }.Concat(tokenId);

    private static UInt160 GetIssuer()
        => (UInt160)Storage.Get(Storage.CurrentContext, new byte[] { Prefix_Issuer });
}