ERC-2981 — NFT Royalty Standard

Back to Token Standards

ERC-2981: NFT Royalty Standard

ERC-2981 lets NFT contracts advertise a single royalty recipient and percentage. Marketplaces query royaltyInfo(tokenId, salePrice) and pay the receiver before settling buyer/seller.

Limitations

• Single recipient — splitting royalties across artists, labels, and platforms requires deploying a payment splitter.
• Implicit currency — paid in whatever the sale used (typically ETH/WETH).
• Honour system — marketplaces must voluntarily query and pay; no on-chain enforcement.

Neo Equivalent: NEP-24 (First-Class Splits)

NEP-24's royaltyInfo returns an array of [recipient, amount] pairs — splits across artist + label + platform are first-class — and adds an explicit royaltyToken parameter so royalties can be paid in GAS, NEO, or any NEP-17.

Live on Neo TestNet

Both implementations deployed on Neo N3 TestNet.

Implementation	TestNet Address	Contract Hash	Deploy Tx
Solidity (neo-solc)	NQhcPMzycbfy5h4ZBg7vrbAvioa41KdR6i	0xade57dfd9ad85fff8dca3845cf22206346468234	0x36e5acd5…417ee5
Neo C# (nccs)	NgTke4MQShakWQpPvskjqX1XEmpMF4EmSC	0xbf3fe7eb875750c81c2915d53123c380685a65e1	(re-used)

Checked-in snapshot verifies symbol, mint, royalty configuration, and totalSupply; the manifest now also asserts royalty amount calculation. docs/standards-mirror/deployments/erc-2981/.

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

interface IERC2981 {
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external view returns (address receiver, uint256 royaltyAmount);
}

contract NFTWithRoyalty is IERC2981 {
    struct Royalty { address receiver; uint96 basisPoints; }

    Royalty                            public defaultRoyalty;
    mapping(uint256 => Royalty)        public tokenRoyalty;

    function setDefaultRoyalty(address receiver, uint96 bps) public {
        require(bps <= 10_000, "bps > 100%");
        defaultRoyalty = Royalty(receiver, bps);
    }

    function setTokenRoyalty(uint256 tokenId, address receiver, uint96 bps) public {
        require(bps <= 10_000, "bps > 100%");
        tokenRoyalty[tokenId] = Royalty(receiver, bps);
    }

    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external view returns (address receiver, uint256 royaltyAmount)
    {
        Royalty memory r = tokenRoyalty[tokenId].receiver != address(0)
            ? tokenRoyalty[tokenId]
            : defaultRoyalty;
        return (r.receiver, (salePrice * r.basisPoints) / 10_000);
    }
}

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("RoyaltyNFT")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep11, NepStandard.Nep24)]
public class RoyaltyNFT : SmartContract
{
    private const byte Prefix_RoyaltyDefault = 0x10;
    private const byte Prefix_RoyaltyToken   = 0x11;

    /// <summary>
    /// NEP-24 royaltyInfo: returns an array of [recipient, amount] pairs
    /// supporting split royalties (artist + label + platform + ...).
    /// </summary>
    public static (UInt160, BigInteger)[] RoyaltyInfo(
        ByteString tokenId, UInt160 royaltyToken, BigInteger salePrice)
    {
        var raw = Storage.Get(Storage.CurrentContext,
                              new byte[] { Prefix_RoyaltyToken }.Concat(tokenId))
               ?? Storage.Get(Storage.CurrentContext,
                              new byte[] { Prefix_RoyaltyDefault });
        if (raw == null) return new (UInt160, BigInteger)[0];

        var pairs = (object[])StdLib.Deserialize(raw);
        var output = new (UInt160, BigInteger)[pairs.Length];
        for (int i = 0; i < pairs.Length; i++)
        {
            var p = (object[])pairs[i];
            output[i] = ((UInt160)p[0], salePrice * (BigInteger)p[1] / 10_000);
        }
        return output;
    }

    public static void SetDefaultRoyalty((UInt160, BigInteger)[] recipients)
    {
        if (!Runtime.CheckWitness(GetAdmin())) throw new Exception("admin only");
        BigInteger total = 0;
        foreach (var (_, bps) in recipients) total += bps;
        if (total > 10_000) throw new Exception("total bps > 100%");
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_RoyaltyDefault },
                    StdLib.Serialize(recipients));
    }

    private static UInt160 GetAdmin() => (UInt160)"0x0000000000000000000000000000000000000000";
}