ERC-6454 — Minimal Transferable NFT Detection Interface

Back to Token Standards

ERC-6454: Minimal Transferable Detection

ERC-6454 standardises a single boolean predicate: "is this token transferable from X to Y right now?" — without revealing why it might not be (lock state, soulbound flag, time-lock, custom rule). Marketplaces, indexers, and wallets call this to gray out "transfer" buttons before attempting and failing.

The standard is intentionally minimal: just one method, no events, no storage shape mandated. The implementation can encode any combination of locks (per ERC-6982), guards (per ERC-6147), soulbound flags (per ERC-5192 / ERC-5484), or custom logic.

Required Interface

interface IERC6454 {
    function isTransferable(uint256 tokenId, address from, address to)
        external view returns (bool);
}

That's it. The token contract knows its own rules; this interface exposes them as a single yes/no.

Neo Equivalent: NEP-11 + IsTransferable View

public static bool IsTransferable(ByteString tokenId, UInt160 from, UInt160 to)
{
    // Compose any number of internal checks.
    if (IsLocked(tokenId))                                          return false;
    if (IsSoulbound(tokenId))                                       return false;
    if (HasGuard(tokenId) && !IsGuardApproved(tokenId, from, to))   return false;
    if (TransferLimit(tokenId) > 0 && TransferCount(tokenId) >= TransferLimit(tokenId))
        return false;
    return true;
}

ERC-6454 (Ethereum)	Neo Equivalent	Notes
isTransferable(tokenId, from, to)	IsTransferable(tokenId, from, to) view	Direct port
Composes with any restriction mechanism	Composes with NEP-11 base + extension flags	Same role

Composition

ERC-6454 is the public-facing query for any combination of:

• ERC-5192 — soulbound (binary).
• ERC-5484 — consensual soulbound.
• ERC-6982 — default lockable.
• ERC-7066 — lockable extension.
• ERC-6147 — NFT guard.
• ERC-7634 — limited transfer count.
• ERC-7144 — transfer-validation hook.

Implementing ERC-6454 lets all these mechanisms surface uniformly to external consumers via one selector — marketplaces don't need to detect each restriction type separately.

Why It Matters

Without ERC-6454, marketplace contracts have to:

1. Try to transfer.
2. If it reverts, parse the revert reason.
3. Map the revert reason to a UI message.

With ERC-6454, the marketplace queries the predicate before attempting and shows the right state in the UI. Reverts on actual transfer become rare — only race conditions between the query and the transfer trigger them.

Migration Notes

For NEP-11 contracts adopting ERC-6454:

1. Implement the IsTransferable view aggregating all your existing restriction predicates.
2. Marketplaces call this before listing or before allowing a sale to complete; non-transferable items are hidden or marked "non-transferable".
3. The view is [Safe] — make sure the manifest advertises it as read-only.

For brand-new collections, expose ERC-6454 from day one even if the default returns true (just return true); future restriction extensions plug into the same view without changing the public selector.

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

contract ERC6454 {
    function isTransferable(uint256 tokenId, address from, address to)
        external view returns (bool)
    {
        // Compose all restriction mechanisms.
        if (_isLocked(tokenId))                                        return false;
        if (_isSoulbound(tokenId))                                     return false;
        if (_transferLimitReached(tokenId))                            return false;
        return true;
    }

    function _isLocked(uint256 tokenId) internal view returns (bool) { return false; }  // ERC-6982/7066
    function _isSoulbound(uint256 tokenId) internal view returns (bool) { return false; }  // ERC-5192
    function _transferLimitReached(uint256 tokenId) internal view returns (bool) { return false; }  // ERC-7634
}

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

    [Safe]
    public static bool IsTransferable(ByteString tokenId, UInt160 from, UInt160 to)
    {
        // Aggregate every restriction mechanism this contract implements.
        if (IsLocked(tokenId))                                                    return false;
        if (IsSoulbound(tokenId))                                                 return false;
        if (TransferLimit(tokenId) > 0 && TransferCount(tokenId) >= TransferLimit(tokenId))
            return false;
        // Add more checks as the contract gains restriction extensions.
        return true;
    }

    // Stubs — replace with actual logic from the chosen extensions.
    private static bool IsLocked(ByteString tokenId)              => false;
    private static bool IsSoulbound(ByteString tokenId)           => false;
    private static BigInteger TransferLimit(ByteString tokenId)   => 0;
    private static BigInteger TransferCount(ByteString tokenId)   => 0;
}

Marketplace Adoption Recipe

// Off-chain marketplace UI.
async function canList(contract: string, tokenId: string, owner: string, marketplace: string) {
    const result = await rpc.invokeFunction(contract, 'isTransferable', [tokenId, owner, marketplace]);
    return result.state === 'HALT' && result.stack[0].value === true;
}

If the predicate returns false, the marketplace UI shows a "non-transferable" badge instead of a list-for-sale button. This prevents users wasting GAS on transfers that will revert.