ERC-4400 — EIP-721 Consumable Extension

Back to Token Standards

ERC-4400: EIP-721 Consumable Extension

ERC-4400 is the earlier consumable-NFT pattern that ERC-2135 and ERC-6672 later extended. Each NFT has a single consumer address that can be set by the owner; the consumer is allowed to "consume" the NFT once. Simpler than 2135 (no consumed-flag tracking) and 6672 (no per-operator state).

Common in:

• Single-use voucher NFTs that delegate consumption to a service.
• Event tickets where the venue is the consumer.
• Subscription NFTs delegating period-end actions to a scheduler.

Required Interface

interface IERC4400 {
    event ConsumerChanged(address indexed owner, address indexed consumer, uint256 indexed tokenId);

    function changeConsumer(address consumer, uint256 tokenId) external;
    function consumerOf(uint256 tokenId) external view returns (address);
}

The owner sets a consumer via changeConsumer; the consumer reads the slot via consumerOf. Whether the consumer is reset on transfer or persists is implementation-defined (the OpenZeppelin reference clears it on transfer).

Neo Equivalent: NEP-11 + Per-Token Consumer Slot

public static void ChangeConsumer(UInt160 consumer, ByteString tokenId)
{
    var owner = OwnerOf(tokenId);
    if (!Runtime.CheckWitness(owner)) throw new Exception("NEP11:NotOwner");
    Storage.Put(Storage.CurrentContext, ConsumerKey(tokenId), consumer);
    OnConsumerChanged(owner, consumer, tokenId);
}

public static UInt160 ConsumerOf(ByteString tokenId)
{
    var raw = Storage.Get(Storage.CurrentContext, ConsumerKey(tokenId));
    return raw is null ? null : (UInt160)raw;
}

// Nep11Token<T> has no virtual hook; use `public new static`.
public new static bool Transfer(UInt160 to, ByteString tokenId, object data = null)
{
    var ok = Nep11Token<TokenState>.Transfer(to, tokenId, data);
    if (ok) Storage.Delete(Storage.CurrentContext, ConsumerKey(tokenId));  // clear on transfer
    return ok;
}

ERC-4400 (Ethereum)	Neo Equivalent	Notes
changeConsumer(consumer, tokenId)	ChangeConsumer(consumer, tokenId) owner-witness-checked
consumerOf(tokenId)	ConsumerOf(tokenId) view
Cleared on transfer (OZ ref)	OnTransfer override deletes the slot	Direct port

Comparison with ERC-2135 and ERC-6672

Standard	Tracks consumed	Per-operator
ERC-4400 (this)	No (just authorises a consumer)	One consumer per token
ERC-2135	Yes (binary flag)	One consumer per token
ERC-6672	Yes (per redemptionId)	Multiple operators per token

Pick ERC-4400 for the simplest "delegate consumption" use case; pick 2135 for single-use vouchers; pick 6672 for multi-event memberships.

Composition

• ERC-2135 — single-use consumable. ERC-4400 is lighter (no consumed-flag).
• ERC-6672 — multi-redeemable. Heavier; for multi-event tracking.
• ERC-4907 — rental NFT. The renter is often also the consumer for the rental window.

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

contract ERC4400 {
    mapping(uint256 => address) public consumerOf;

    event ConsumerChanged(address indexed owner, address indexed consumer, uint256 indexed tokenId);

    function changeConsumer(address consumer, uint256 tokenId) external {
        // ... owner check ...
        consumerOf[tokenId] = consumer;
        emit ConsumerChanged(msg.sender, consumer, tokenId);
    }
}

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

    private const byte Prefix_Consumer = 0x20;

    [DisplayName("ConsumerChanged")]
    public static event Action<UInt160, UInt160, ByteString> OnConsumerChanged;

    public static void ChangeConsumer(UInt160 consumer, ByteString tokenId)
    {
        var owner = OwnerOf(tokenId);
        if (!Runtime.CheckWitness(owner)) throw new Exception("NEP11:NotOwner");
        Storage.Put(Storage.CurrentContext, ConsumerKey(tokenId), consumer);
        OnConsumerChanged(owner, consumer, tokenId);
    }

    public static UInt160 ConsumerOf(ByteString tokenId)
    {
        var raw = Storage.Get(Storage.CurrentContext, ConsumerKey(tokenId));
        return raw is null ? null : (UInt160)raw;
    }

    public new static bool Transfer(UInt160 to, ByteString tokenId, object data = null)
    {
        var ok = Nep11Token<TokenState>.Transfer(to, tokenId, data);
        if (ok) Storage.Delete(Storage.CurrentContext, ConsumerKey(tokenId));
        return ok;
    }

    private static byte[] ConsumerKey(ByteString tokenId) => new byte[] { Prefix_Consumer }.Concat(tokenId);
}