ERC-5216 — ERC-1155 Allowance Extension

Back to Token Standards

ERC-5216: ERC-1155 Per-tokenId Allowance

ERC-1155's standard setApprovalForAll is all-or-nothing — either the operator can move every token of every id the owner holds, or none. ERC-5216 adds per-tokenId per-spender amount allowances, matching ERC-20's granular approval model. Used for:

• DEX trading — limit how much of any one tokenId a router can move on your behalf.
• Permissioned transfers — grant a contract spending rights for a specific item without granting blanket access.
• Recurring payment NFTs — allow a payment service to draw fixed amounts of a tokenId at intervals.

Required Interface (delta from ERC-1155)

interface IERC5216 {
    event ApprovalById(address indexed account, address indexed operator,
                       uint256 id, uint256 amount);

    function approveById(address operator, uint256 id, uint256 amount) external;
    function allowanceById(address account, address operator, uint256 id)
        external view returns (uint256);
}

safeTransferFrom checks both the global isApprovedForAll and the per-(owner, operator, tokenId) allowance, decrementing the allowance on use.

Neo Equivalent: NEP-11 Divisible + Per-(owner, spender, id) Allowance

NEP-11 divisible is the multi-token NEP-11 variant; the allowance extension adds three storage keys:

public static void ApproveById(UInt160 spender, ByteString tokenId, BigInteger amount)
{
    var owner = Runtime.CallingScriptHash;
    if (!Runtime.CheckWitness(owner)) throw new Exception("NEP11:NoAuth");
    Storage.Put(Storage.CurrentContext, AllowanceKey(owner, spender, tokenId), amount);
    OnApprovalById(owner, spender, tokenId, amount);
}

public static BigInteger AllowanceById(UInt160 owner, UInt160 spender, ByteString tokenId)
    => (BigInteger)(Storage.Get(Storage.CurrentContext, AllowanceKey(owner, spender, tokenId)) ?? ByteString.Empty);

public static bool TransferById(UInt160 from, UInt160 to, ByteString tokenId, BigInteger amount)
{
    if (!Runtime.CheckWitness(Runtime.CallingScriptHash)) throw new Exception("NEP11:NoAuth");
    var spender = Runtime.CallingScriptHash;

    if (!from.Equals(spender))
    {
        var allowance = AllowanceById(from, spender, tokenId);
        if (allowance < amount) throw new Exception("NEP11:InsufficientAllowance");
        Storage.Put(Storage.CurrentContext, AllowanceKey(from, spender, tokenId), allowance - amount);
    }

    return base.Transfer(from, to, amount, tokenId, null);
}

ERC-5216 (Ethereum)	Neo Equivalent	Notes
approveById(operator, id, amount)	ApproveById(spender, tokenId, amount) owner-witness-checked
allowanceById(account, operator, id)	AllowanceById(owner, spender, tokenId) view
safeTransferFrom decrements allowance	TransferById decrements allowance pre-transfer
Combined with isApprovedForAll	Combined with NEP-11 base operator approval	Either path authorises

Composition

• ERC-1155 — base. ERC-5216 is the granular-allowance extension.
• ERC-5615 — supply extension. Pair with ERC-5216 for full ERC-1155 functionality parity.

Migration Notes

For DEX integrations:

1. Routers prefer per-tokenId approvals for safety; ERC-5216 lets collections support this.
2. The approveById call is per-tokenId — for users approving many tokenIds, this becomes expensive. Off-chain helpers can batch the Approve calls into a single transaction script.

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

contract ERC5216 {
    mapping(address => mapping(address => mapping(uint256 => uint256))) public allowanceById;

    event ApprovalById(address indexed account, address indexed operator,
                       uint256 id, uint256 amount);

    function approveById(address operator, uint256 id, uint256 amount) external {
        allowanceById[msg.sender][operator][id] = amount;
        emit ApprovalById(msg.sender, operator, id, amount);
    }

    function safeTransferFrom(address from, address to, uint256 id, uint256 amount,
                              bytes calldata data) external {
        if (msg.sender != from) {
            uint256 allowed = allowanceById[from][msg.sender][id];
            require(allowed >= amount, "exceeds allowance");
            allowanceById[from][msg.sender][id] = allowed - amount;
        }
        // ... base ERC-1155 transfer ...
    }
}

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

    private const byte Prefix_Allowance = 0x30;

    [DisplayName("ApprovalById")]
    public static event Action<UInt160, UInt160, ByteString, BigInteger> OnApprovalById;

    public static void ApproveById(UInt160 spender, ByteString tokenId, BigInteger amount)
    {
        var owner = Runtime.CallingScriptHash;
        if (!Runtime.CheckWitness(owner)) throw new Exception("NEP11:NoAuth");
        Storage.Put(Storage.CurrentContext, AllowanceKey(owner, spender, tokenId), amount);
        OnApprovalById(owner, spender, tokenId, amount);
    }

    public static BigInteger AllowanceById(UInt160 owner, UInt160 spender, ByteString tokenId)
        => (BigInteger)(Storage.Get(Storage.CurrentContext, AllowanceKey(owner, spender, tokenId)) ?? ByteString.Empty);

    public static bool TransferFromById(UInt160 from, UInt160 to, ByteString tokenId, BigInteger amount)
    {
        var spender = Runtime.CallingScriptHash;
        if (!Runtime.CheckWitness(spender)) throw new Exception("NEP11:NoAuth");

        if (!from.Equals(spender))
        {
            var allowed = AllowanceById(from, spender, tokenId);
            if (allowed < amount) throw new Exception("NEP11:InsufficientAllowance");
            Storage.Put(Storage.CurrentContext, AllowanceKey(from, spender, tokenId), allowed - amount);
        }
        // Delegate to base divisible Transfer.
        return false;  // simplified; call into Nep11 divisible base
    }

    private static byte[] AllowanceKey(UInt160 owner, UInt160 spender, ByteString tokenId)
        => new byte[] { Prefix_Allowance }.Concat(owner).Concat(spender).Concat(tokenId);
}