ERC-6220 — Composable NFTs utilizing Equippable Parts

Back to Token Standards

ERC-6220: Equippable NFTs (RMRK Equippable)

ERC-6220 layers modular assembly on top of ERC-6059 nestable + ERC-5773 multi-asset NFTs. A parent NFT (e.g. a game character) has named equip slots (helmet, sword, shield); child NFTs whose contracts publish themselves as compatible parts can be equipped into those slots, changing the parent's rendered composition. The renderer reads the parent's active composition and overlays the child equipped assets in the right positions.

The standard introduces three new primitives:

• Catalog — a registry contract listing slots and parts that parents can declare equippable.
• Equip slot — a (parent, slot, child) tuple stored in the parent's contract.
• Equippable definition — a child contract declaring "I'm equippable into slot S of catalog C with asset A".

Required Interface (abridged)

interface IERC6220 {
    struct IntakeEquip {
        uint256 tokenId;
        uint256 childIndex;
        uint64  assetId;
        uint64  slotPartId;
        address childAddress;
        uint256 childTokenId;
        uint64  childAssetId;
    }

    event ChildAssetEquipped(uint256 indexed tokenId, uint64 indexed assetId, uint64 indexed slotPartId,
                             uint256 childTokenId, address childAddress, uint64 childAssetId);
    event ChildAssetUnequipped(uint256 indexed tokenId, uint64 indexed assetId, uint64 indexed slotPartId);

    function equip(IntakeEquip calldata data) external;
    function unequip(uint256 tokenId, uint64 assetId, uint64 slotPartId) external;

    function getEquipment(uint256 tokenId, address catalog, uint64 slotPartId)
        external view returns (uint64 assetId, uint64 childAssetId, uint256 childTokenId, address childAddress);
}

Neo Equivalent: NEP-11 + Catalog Contract + Equip-Slot Storage

The Neo port composes:

1. Catalog contract — separate NEP-11 listing slot/part metadata.
2. Equippable parent NFT — extends the [ERC-6059 mirror](./erc-6059) with equip-slot storage (tokenId, slot) → (childContract, childTokenId, childAssetId).
3. Equippable child NFT — exposes IsEquippable(slotId) for the parent to verify before equipping.

public static void Equip(ByteString tokenId, BigInteger assetId, BigInteger slotPartId,
                        UInt160 childContract, ByteString childTokenId, BigInteger childAssetId)
{
    if (!Runtime.CheckWitness(OwnerOf(tokenId))) throw new Exception("NEP11:NotOwner");

    // Verify child is a registered child of this parent (per ERC-6059 mirror).
    if (!IsChild(tokenId, childContract, childTokenId)) throw new Exception("NEP11:NotChild");

    // Verify child declares itself equippable into this slot.
    var ok = (bool)Contract.Call(childContract, "isEquippable", CallFlags.ReadOnly,
        new object[] { childTokenId, slotPartId, childAssetId });
    if (!ok) throw new Exception("NEP11:NotEquippable");

    Storage.Put(Storage.CurrentContext, EquipKey(tokenId, slotPartId),
        StdLib.Serialize(new object[] { assetId, childAssetId, childTokenId, childContract }));
    OnChildAssetEquipped(tokenId, assetId, slotPartId, childTokenId, childContract, childAssetId);
}

ERC-6220 (Ethereum)	Neo Equivalent	Notes
Catalog contract	Separate Neo C# catalog contract	Registry of slots + parts
equip(IntakeEquip)	Equip(tokenId, assetId, slotPartId, …)	Owner-witness-checked
unequip(tokenId, assetId, slotPartId)	Unequip(tokenId, assetId, slotPartId)	Owner-witness-checked
getEquipment(tokenId, catalog, slotPartId)	GetEquipment(tokenId, slotPartId)	Returns the equipped tuple or null
Child IsEquippable declaration	Child contract's IsEquippable(tokenId, slotId, assetId) view	Cross-contract verification

Composition Stack

The full RMRK Equippable stack composes four mirror pages:

1. NEP-11 base — basic NFT.
2. ERC-5773 — multi-asset (the parent has multiple renderable variants; equipping assets adds to the active set).
3. ERC-6059 — nestable (the equipped child is also a nested child of the parent).
4. ERC-6220 (this page) — equip slot mapping that decides which children render where.

Migration Notes

For RMRK Equippable collections porting to Neo:

1. Implement the catalog contract as a thin Neo C# service exposing getSlot(slotId) / getParts(catalogId).
2. The parent contract inherits NEP-11 + adds nestable + multi-asset + equip storage.
3. Child contracts add the IsEquippable(tokenId, slotId, assetId) view declaring compatibility.
4. The renderer (off-chain) resolves the parent's active assets, the per-slot equipment, and overlays the child rendered assets.

The on-chain footprint is the heaviest of any NFT extension — because the standard composes four other standards, the storage and gas cost per equip / unequip is non-trivial. Worth it for high-fidelity composable game assets; overkill for simple inventory systems.

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

interface IERC6220Equippable {
    function isEquippable(uint256 tokenId, uint64 slotPartId, uint64 assetId)
        external view returns (bool);
}

contract Equippable6220 {
    struct Equipment {
        uint64  assetId;
        uint64  childAssetId;
        uint256 childTokenId;
        address childAddress;
    }
    mapping(uint256 => mapping(uint64 => Equipment)) internal _equipped;  // tokenId → slotId → eq

    event ChildAssetEquipped(uint256 indexed tokenId, uint64 indexed assetId, uint64 indexed slotPartId,
                             uint256 childTokenId, address childAddress, uint64 childAssetId);

    function equip(uint256 tokenId, uint64 assetId, uint64 slotPartId,
                   address childAddress, uint256 childTokenId, uint64 childAssetId) external
    {
        // ... ownership + nestable child check ...
        require(IERC6220Equippable(childAddress).isEquippable(childTokenId, slotPartId, childAssetId), "not equippable");
        _equipped[tokenId][slotPartId] = Equipment(assetId, childAssetId, childTokenId, childAddress);
        emit ChildAssetEquipped(tokenId, assetId, slotPartId, childTokenId, childAddress, childAssetId);
    }
}

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

    private const byte Prefix_Equipped = 0x40;

    [DisplayName("ChildAssetEquipped")]
    public static event Action<ByteString, BigInteger, BigInteger, ByteString, UInt160, BigInteger> OnEquipped;
    [DisplayName("ChildAssetUnequipped")]
    public static event Action<ByteString, BigInteger, BigInteger> OnUnequipped;

    public static void Equip(ByteString tokenId, BigInteger assetId, BigInteger slotPartId,
                             UInt160 childContract, ByteString childTokenId, BigInteger childAssetId)
    {
        if (!Runtime.CheckWitness(OwnerOf(tokenId))) throw new Exception("NEP11:NotOwner");

        // Verify the child is in fact nested under this parent (per ERC-6059 / nestable).
        // ... cross-call this contract's NEP-6059 ChildrenOf to confirm ...

        // Verify the child contract declares this child as equippable.
        var ok = (bool)Contract.Call(childContract, "isEquippable", CallFlags.ReadOnly,
            new object[] { childTokenId, slotPartId, childAssetId });
        if (!ok) throw new Exception("NEP11:NotEquippable");

        var equipment = new object[] { assetId, childAssetId, childTokenId, childContract };
        Storage.Put(Storage.CurrentContext, EquipKey(tokenId, slotPartId), StdLib.Serialize(equipment));
        OnEquipped(tokenId, assetId, slotPartId, childTokenId, childContract, childAssetId);
    }

    public static void Unequip(ByteString tokenId, BigInteger assetId, BigInteger slotPartId)
    {
        if (!Runtime.CheckWitness(OwnerOf(tokenId))) throw new Exception("NEP11:NotOwner");
        Storage.Delete(Storage.CurrentContext, EquipKey(tokenId, slotPartId));
        OnUnequipped(tokenId, assetId, slotPartId);
    }

    public static (BigInteger, BigInteger, ByteString, UInt160) GetEquipment(ByteString tokenId, BigInteger slotPartId)
    {
        var raw = Storage.Get(Storage.CurrentContext, EquipKey(tokenId, slotPartId));
        if (raw is null) return (0, 0, null, null);
        var arr = (object[])StdLib.Deserialize((ByteString)raw);
        return ((BigInteger)arr[0], (BigInteger)arr[1], (ByteString)arr[2], (UInt160)arr[3]);
    }

    private static byte[] EquipKey(ByteString tokenId, BigInteger slotPartId)
        => new byte[] { Prefix_Equipped }.Concat(tokenId).Concat((ByteString)(byte[])slotPartId.ToByteArray());
}

// Companion child-side contract — equippable into specific slots.
[DisplayName("EquippableSword")]
public class EquippableSword : Nep11Token<TokenState>
{
    public static bool IsEquippable(ByteString tokenId, BigInteger slotId, BigInteger assetId)
    {
        // This sword fits the "MAIN_HAND" slot only.
        return slotId == (BigInteger)0x4D41494E5F48414E44;  // hex "MAIN_HAND"
    }
}

Operational Cost

A full equip operation does:

• 1 NEP-11 ownership check (cheap).
• 1 nestable child verification (storage read + iterator).
• 1 cross-contract call to child's IsEquippable.
• 1 storage write to Prefix_Equipped.

Estimated GAS: ~2-3M datoshi per equip; comparable on Neo and Ethereum. Unequip is roughly half as expensive (just a storage delete).