ERC-4910 — Royalty Bearing NFTs

Back to Token Standards

ERC-4910: Royalty Bearing NFTs

ERC-4910 goes beyond ERC-2981 (which only declares royalty info) by enforcing royalty distribution on-chain. The NFT contract escrows royalty payments at sale time, lets multiple recipients (artist, label, charity) claim their share, and supports royalty-recipient changes through a managed flow.

Used by:

• Music NFTs with multi-party splits (artist + producer + label + sample owners).
• Collaborative art with co-creator royalty splits.
• Charity NFTs automatically routing a fraction to a charitable address.
• DAO-owned NFTs distributing royalty across DAO members.

Required Interface (delta from ERC-2981)

interface IERC4910 {
    event RoyaltiesPaid(uint256 indexed tokenId, uint256 totalAmount);
    event RoyaltyClaimed(address indexed recipient, uint256 amount);

    struct RoyaltyRecipient { address recipient; uint256 share; }  // share in basis points

    function setRoyaltyRecipients(uint256 tokenId, RoyaltyRecipient[] calldata recipients) external;
    function distributeRoyalties(uint256 tokenId, uint256 amount) external;
    function claimRoyalties() external;
    function pendingRoyaltiesOf(address recipient) external view returns (uint256);
}

The marketplace calls distributeRoyalties(tokenId, totalRoyalty) on every sale; the contract escrows and tracks per-recipient balances. Recipients call claimRoyalties() to withdraw their accumulated share.

Neo Equivalent: NEP-11 + Escrow + Claim Flow

public static void DistributeRoyalties(ByteString tokenId, BigInteger totalAmount)
{
    var recipients = GetRecipients(tokenId);
    BigInteger sumShares = 0;
    for (var i = 0; i < recipients.Length; i++)
        sumShares += (BigInteger)((Map<string, object>)recipients[i])["share"];
    if (sumShares != 10000) throw new Exception("NEP24:SharesNot100Percent");

    for (var i = 0; i < recipients.Length; i++)
    {
        var entry = (Map<string, object>)recipients[i];
        var addr  = (UInt160)entry["recipient"];
        var share = (BigInteger)entry["share"];
        var amount = (totalAmount * share) / 10000;
        var key = PendingKey(addr);
        var prev = (BigInteger)(Storage.Get(Storage.CurrentContext, key) ?? ByteString.Empty);
        Storage.Put(Storage.CurrentContext, key, prev + amount);
    }
    OnRoyaltiesPaid(tokenId, totalAmount);
}

public static void ClaimRoyalties()
{
    var caller = Runtime.CallingScriptHash;
    if (!Runtime.CheckWitness(caller)) throw new Exception("NEP24:NoAuth");
    var key = PendingKey(caller);
    var pending = (BigInteger)(Storage.Get(Storage.CurrentContext, key) ?? ByteString.Empty);
    if (pending == 0) return;
    Storage.Put(Storage.CurrentContext, key, 0);
    Contract.Call(GAS.Hash, "transfer", CallFlags.All,
        new object[] { Runtime.ExecutingScriptHash, caller, pending, null });
    OnRoyaltyClaimed(caller, pending);
}

ERC-4910 (Ethereum)	Neo Equivalent	Notes
distributeRoyalties(tokenId, amount)	DistributeRoyalties(...) marketplace-callable	Marketplace escrows royalty into NFT contract
claimRoyalties()	ClaimRoyalties() recipient-witness-checked	Pull pattern — recipients withdraw
pendingRoyaltiesOf(recipient)	PendingRoyaltiesOf(recipient) view
Recipients + shares per tokenId	(tokenId → [{ recipient, share_bps }]) storage
setRoyaltyRecipients(...)	SetRoyaltyRecipients(...) issuer-witness-checked	Update splits

Composition

• ERC-2981 — base royalty info. ERC-4910 adds the enforcement / distribution layer.
• ERC-6105 — direct NFT trading. The trading contract calls DistributeRoyalties on each sale.
• ERC-5375 — author + consent. Authors register themselves as royalty recipients via the consent flow.

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

contract ERC4910 {
    struct Recipient { address recipient; uint256 share; }
    mapping(uint256 => Recipient[]) internal _recipients;
    mapping(address => uint256) public pendingRoyaltiesOf;

    event RoyaltiesPaid(uint256 indexed tokenId, uint256 totalAmount);
    event RoyaltyClaimed(address indexed recipient, uint256 amount);

    function distributeRoyalties(uint256 tokenId, uint256 amount) external {
        Recipient[] storage recipients = _recipients[tokenId];
        for (uint256 i = 0; i < recipients.length; ++i) {
            uint256 share = (amount * recipients[i].share) / 10000;
            pendingRoyaltiesOf[recipients[i].recipient] += share;
        }
        emit RoyaltiesPaid(tokenId, amount);
    }

    function claimRoyalties() external {
        uint256 pending = pendingRoyaltiesOf[msg.sender];
        if (pending == 0) return;
        pendingRoyaltiesOf[msg.sender] = 0;
        payable(msg.sender).transfer(pending);
        emit RoyaltyClaimed(msg.sender, pending);
    }
}

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

    private const byte Prefix_Recipients = 0x10;
    private const byte Prefix_Pending    = 0x11;

    [DisplayName("RoyaltiesPaid")]
    public static event Action<ByteString, BigInteger> OnRoyaltiesPaid;
    [DisplayName("RoyaltyClaimed")]
    public static event Action<UInt160, BigInteger> OnRoyaltyClaimed;

    public static void SetRoyaltyRecipients(ByteString tokenId, object[] recipients)
    {
        if (!Runtime.CheckWitness(GetIssuer())) throw new Exception("NEP24:NotIssuer");
        Storage.Put(Storage.CurrentContext, RecipientsKey(tokenId), StdLib.Serialize(recipients));
    }

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

    public static void DistributeRoyalties(ByteString tokenId, BigInteger totalAmount)
    {
        var recipients = GetRecipients(tokenId);
        for (var i = 0; i < recipients.Length; i++)
        {
            var entry = (Map<string, object>)recipients[i];
            var addr  = (UInt160)entry["recipient"];
            var share = (BigInteger)entry["share"];
            var amount = (totalAmount * share) / 10000;
            var key = PendingKey(addr);
            var prev = (BigInteger)(Storage.Get(Storage.CurrentContext, key) ?? ByteString.Empty);
            Storage.Put(Storage.CurrentContext, key, prev + amount);
        }
        OnRoyaltiesPaid(tokenId, totalAmount);
    }

    public static void ClaimRoyalties()
    {
        var caller = Runtime.CallingScriptHash;
        if (!Runtime.CheckWitness(caller)) throw new Exception("NEP24:NoAuth");
        var key = PendingKey(caller);
        var pending = (BigInteger)(Storage.Get(Storage.CurrentContext, key) ?? ByteString.Empty);
        if (pending == 0) return;
        Storage.Put(Storage.CurrentContext, key, 0);
        Contract.Call(GAS.Hash, "transfer", CallFlags.All,
            new object[] { Runtime.ExecutingScriptHash, caller, pending, null });
        OnRoyaltyClaimed(caller, pending);
    }

    public static BigInteger PendingRoyaltiesOf(UInt160 recipient)
        => (BigInteger)(Storage.Get(Storage.CurrentContext, PendingKey(recipient)) ?? ByteString.Empty);

    private static byte[] RecipientsKey(ByteString tokenId) => new byte[] { Prefix_Recipients }.Concat(tokenId);
    private static byte[] PendingKey(UInt160 r)             => new byte[] { Prefix_Pending    }.Concat(r);
    private static UInt160 GetIssuer() => (UInt160)"0x0000000000000000000000000000000000000000";
}