ERC-6105 — No Intermediary NFT Trading Protocol

Back to Token Standards

ERC-6105: No-Intermediary NFT Trading

ERC-6105 bakes a listing + atomic swap protocol directly into the NFT contract, eliminating the need for marketplace contracts (OpenSea, Blur, Reservoir) for basic trading. The NFT holder lists their token at a price; any buyer can call buy(tokenId) paying the asking price; the NFT swaps for the payment in a single atomic call. Royalties (per ERC-2981) and protocol fees are paid out automatically.

Goals:

• Eliminate marketplace fees (typically 2-2.5%) — the NFT contract charges nothing beyond the configured royalty.
• Reduce smart-contract risk — no separate marketplace contract to audit or compromise.
• Standardise the listing UX — wallets show the listed price directly; no marketplace API integration needed.

Required Interface

interface IERC6105 {
    event UpdateListing(uint256 indexed tokenId, address indexed from,
                        uint256 salePrice, uint64 expires,
                        address supportedToken, address indexed benchmarkPrice);
    event Purchase(uint256 indexed tokenId, address indexed from, address indexed to,
                   address supportedToken, uint256 salePrice, address royaltyRecipient,
                   uint256 royaltyAmount);

    function listItem(uint256 tokenId, uint256 salePrice, uint64 expires) external;
    function listItem(uint256 tokenId, uint256 salePrice, uint64 expires,
                      address supportedToken) external;
    function unlistItem(uint256 tokenId) external;
    function buyItem(uint256 tokenId) external payable;
    function getListing(uint256 tokenId)
        external view returns (address from, uint256 salePrice, uint64 expires, address supportedToken);
}

The supportedToken parameter lets sellers price in any ERC-20 (USDC, DAI, custom currency) instead of just ETH. benchmarkPrice is an oracle reference for off-chain UI rendering.

Neo Equivalent: NEP-11 with Built-In Listing + Atomic Swap

The Neo port stores listings per-tokenId in the NFT contract; BuyItem pulls the payment via NEP-17 transfer, splits royalty + payment to seller, and transfers the NFT — all in one transaction. No separate marketplace contract.

public static void ListItem(ByteString tokenId, BigInteger salePrice,
                            BigInteger expires, UInt160 paymentToken)
{
    var owner = OwnerOf(tokenId);
    if (!Runtime.CheckWitness(owner)) throw new Exception("NEP11:NotOwner");
    if (expires <= Runtime.Time)      throw new Exception("NEP11:ExpiryInPast");

    var listing = new Map<string, object>
    {
        ["seller"]    = owner,
        ["salePrice"] = salePrice,
        ["expires"]   = expires,
        ["payment"]   = paymentToken,
    };
    Storage.Put(Storage.CurrentContext, ListingKey(tokenId), StdLib.Serialize(listing));
    OnUpdateListing(tokenId, owner, salePrice, expires, paymentToken);
}

public static void BuyItem(UInt160 buyer, ByteString tokenId)
{
    if (!Runtime.CheckWitness(buyer)) throw new Exception("NEP11:NoAuth");
    var listing = LoadListing(tokenId);
    if (listing is null)                              throw new Exception("NEP11:NotListed");
    if ((BigInteger)listing["expires"] < Runtime.Time) throw new Exception("NEP11:ListingExpired");

    var seller    = (UInt160)listing["seller"];
    var salePrice = (BigInteger)listing["salePrice"];
    var payment   = (UInt160)listing["payment"];

    // Compute royalty per ERC-2981 / NEP-24.
    var (royaltyRecipient, royaltyAmount) = ComputeRoyalty(tokenId, salePrice);
    var sellerAmount = salePrice - royaltyAmount;

    // Pull payment from buyer; split royalty + seller proceeds.
    Contract.Call(payment, "transfer", CallFlags.All,
        new object[] { buyer, seller,           sellerAmount,   null });
    if (royaltyAmount > 0 && royaltyRecipient is not null)
        Contract.Call(payment, "transfer", CallFlags.All,
            new object[] { buyer, royaltyRecipient, royaltyAmount, null });

    // Transfer NFT seller → buyer.
    Storage.Delete(Storage.CurrentContext, ListingKey(tokenId));
    Nep11Token.Transfer(buyer, tokenId, null);  // base NEP-11 transfer
    OnPurchase(tokenId, seller, buyer, payment, salePrice, royaltyRecipient, royaltyAmount);
}

ERC-6105 (Ethereum)	Neo Equivalent	Notes
listItem(tokenId, price, expires)	ListItem(tokenId, price, expires, paymentToken)	NEP-17 paymentToken instead of ETH default
unlistItem(tokenId)	UnlistItem(tokenId) owner-only
buyItem(tokenId) payable	BuyItem(buyer, tokenId) — pulls payment via NEP-17	No payable semantics needed
Purchase event	OnPurchase notification
ERC-2981 royalty integration	NEP-24 royalty integration	Direct equivalent
supportedToken (ERC-20)	paymentToken (NEP-17)	Native cross-token support

Composition

• ERC-2981 — royalties. Critical: ERC-6105 only works correctly with on-chain royalty enforcement.
• ERC-7066 — lockable. Locked NFTs can't be listed for sale.
• ERC-2135 — consumable. Listed NFT cannot be consumed mid-listing without first unlisting.
• ERC-7528 — native asset address. The paymentToken is NativeContract.GAS.Hash for GAS-priced sales.

Migration Notes

For Solidity NFT collections adopting ERC-6105:

1. Add the listing storage prefix.
2. Implement ListItem / UnlistItem / BuyItem / GetListing.
3. Wire ERC-2981 royalty into BuyItem.
4. Document the supported payment tokens (typically USDC + GAS).

For Neo dApps building NFT marketplaces, ERC-6105 is the anti- marketplace — instead of building yet another marketplace contract, adopt the standard so any wallet can buy / sell directly from the NFT contract. Marketplaces become aggregator UIs, not on-chain intermediaries.

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

interface IERC2981 { function royaltyInfo(uint256, uint256) external view returns (address, uint256); }

contract ERC6105 {
    struct Listing {
        address seller;
        uint256 salePrice;
        uint64  expires;
        address paymentToken;
    }
    mapping(uint256 => Listing) public listings;
    mapping(uint256 => address) public ownerOf;

    event UpdateListing(uint256 indexed tokenId, address indexed from,
                        uint256 salePrice, uint64 expires, address paymentToken,
                        address indexed benchmarkPrice);
    event Purchase(uint256 indexed tokenId, address indexed from, address indexed to,
                   address paymentToken, uint256 salePrice,
                   address royaltyRecipient, uint256 royaltyAmount);

    function listItem(uint256 tokenId, uint256 salePrice, uint64 expires, address paymentToken) external {
        require(msg.sender == ownerOf[tokenId], "not owner");
        require(expires > block.timestamp,      "expiry in past");
        listings[tokenId] = Listing(msg.sender, salePrice, expires, paymentToken);
        emit UpdateListing(tokenId, msg.sender, salePrice, expires, paymentToken, address(0));
    }

    function buyItem(uint256 tokenId) external payable {
        Listing memory l = listings[tokenId];
        require(l.expires >= block.timestamp, "expired");

        // Royalty (per ERC-2981).
        (address royaltyRecipient, uint256 royaltyAmount) = IERC2981(address(this)).royaltyInfo(tokenId, l.salePrice);
        uint256 sellerAmount = l.salePrice - royaltyAmount;

        if (l.paymentToken == address(0)) {
            require(msg.value == l.salePrice, "insufficient value");
            payable(l.seller).transfer(sellerAmount);
            if (royaltyAmount > 0) payable(royaltyRecipient).transfer(royaltyAmount);
        } else {
            // ... ERC-20 pull pattern ...
        }

        delete listings[tokenId];
        ownerOf[tokenId] = msg.sender;
        emit Purchase(tokenId, l.seller, msg.sender, l.paymentToken, l.salePrice,
                      royaltyRecipient, royaltyAmount);
    }
}

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

    private const byte Prefix_Listing = 0xC0;

    [DisplayName("UpdateListing")]
    public static event Action<ByteString, UInt160, BigInteger, BigInteger, UInt160> OnUpdateListing;
    [DisplayName("Purchase")]
    public static event Action<ByteString, UInt160, UInt160, UInt160, BigInteger, UInt160, BigInteger> OnPurchase;

    public static void ListItem(ByteString tokenId, BigInteger salePrice,
                                BigInteger expires, UInt160 paymentToken)
    {
        var owner = OwnerOf(tokenId);
        if (!Runtime.CheckWitness(owner)) throw new Exception("NEP11:NotOwner");
        if (expires <= Runtime.Time)      throw new Exception("NEP11:ExpiryInPast");
        if (salePrice <= 0)               throw new Exception("NEP11:InvalidPrice");

        var listing = new Map<string, object>
        {
            ["seller"]    = owner,
            ["salePrice"] = salePrice,
            ["expires"]   = expires,
            ["payment"]   = paymentToken,
        };
        Storage.Put(Storage.CurrentContext, ListingKey(tokenId), StdLib.Serialize(listing));
        OnUpdateListing(tokenId, owner, salePrice, expires, paymentToken);
    }

    public static void UnlistItem(ByteString tokenId)
    {
        var owner = OwnerOf(tokenId);
        if (!Runtime.CheckWitness(owner)) throw new Exception("NEP11:NotOwner");
        Storage.Delete(Storage.CurrentContext, ListingKey(tokenId));
    }

    public static void BuyItem(UInt160 buyer, ByteString tokenId)
    {
        if (!Runtime.CheckWitness(buyer)) throw new Exception("NEP11:NoAuth");

        var raw = Storage.Get(Storage.CurrentContext, ListingKey(tokenId));
        if (raw is null) throw new Exception("NEP11:NotListed");
        var listing = (Map<string, object>)StdLib.Deserialize((ByteString)raw);
        if ((BigInteger)listing["expires"] < Runtime.Time) throw new Exception("NEP11:ListingExpired");

        var seller    = (UInt160)listing["seller"];
        var salePrice = (BigInteger)listing["salePrice"];
        var payment   = (UInt160)listing["payment"];

        // NEP-24 royalty (per the NEP-24 mirror; simplified here).
        var (royaltyRecipient, royaltyAmount) = ComputeRoyalty(tokenId, salePrice);
        var sellerAmount = salePrice - royaltyAmount;

        // Pull payment from buyer.
        Contract.Call(payment, "transfer", CallFlags.All,
            new object[] { buyer, seller, sellerAmount, null });
        if (royaltyAmount > 0 && royaltyRecipient is not null)
            Contract.Call(payment, "transfer", CallFlags.All,
                new object[] { buyer, royaltyRecipient, royaltyAmount, null });

        // Transfer NFT.
        Storage.Delete(Storage.CurrentContext, ListingKey(tokenId));
        Nep11Token.Transfer(buyer, tokenId, null);
        OnPurchase(tokenId, seller, buyer, payment, salePrice, royaltyRecipient, royaltyAmount);
    }

    public static (UInt160, BigInteger, BigInteger, UInt160) GetListing(ByteString tokenId)
    {
        var raw = Storage.Get(Storage.CurrentContext, ListingKey(tokenId));
        if (raw is null) return (null, 0, 0, null);
        var listing = (Map<string, object>)StdLib.Deserialize((ByteString)raw);
        return ((UInt160)listing["seller"], (BigInteger)listing["salePrice"],
                (BigInteger)listing["expires"], (UInt160)listing["payment"]);
    }

    private static (UInt160, BigInteger) ComputeRoyalty(ByteString tokenId, BigInteger salePrice)
    {
        // Stub — call the contract's NEP-24 royaltyInfo if implemented.
        return (null, 0);
    }

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

Why This Beats Aggregator Marketplaces

OpenSea / Reservoir / Blur charge 0–2.5% on every trade. With ERC-6105 the NFT holder lists at price P and the buyer pays exactly P; the only spend beyond the sale is the royalty (per NEP-24) which the artist receives. Aggregators become read-only UIs that index listings across multiple ERC-6105 NFT contracts; on-chain trading happens directly with the NFT contract. The marketplace stack collapses to a pure indexer.