ERC-5570 — Digital Receipt Non-Fungible Tokens

Back to Token Standards

ERC-5570: Digital Receipt NFTs

ERC-5570 standardises a structured metadata schema for digital receipts as NFTs: each NFT represents a single purchase / transaction and carries a machine-readable JSON receipt with merchant, items, totals, currency, taxes, and signatures. Replaces emailed PDF receipts, paper receipts, and per-merchant proprietary loyalty cards with a portable, queryable, on-chain artefact.

Use cases:

• Retail receipts — POS terminals mint a receipt NFT to the shopper's wallet on each purchase. Combined returns / warranties.
• B2B invoices — supplier mints invoice NFT to buyer's contract; used as accounting input.
• Subscription receipts — recurring services mint a renewal receipt per period.
• Restaurant / hospitality — itemised bills as NFTs for splitting, tipping, expense reporting.

The standard is JSON-schema heavy (the on-chain footprint is just NEP- 11 + URI to off-chain JSON), so this mirror documents the shape and the on-chain wrapper.

Required Receipt Fields

{
  "merchantId":     "...",
  "merchantName":   "...",
  "transactionId":  "...",
  "timestamp":      1735689600,
  "currency":       "USD",
  "items": [
    { "name": "Espresso", "qty": 1, "unitPrice": 4.50, "tax": 0.36 },
    { "name": "Croissant", "qty": 2, "unitPrice": 3.25, "tax": 0.52 }
  ],
  "subtotal":  11.00,
  "taxTotal":   0.88,
  "total":     11.88,
  "paymentMethod": "card_visa_4242",
  "merchantSignature": "0x..."
}

The merchantSignature proves the receipt was issued by the merchant (prevents fraudulent receipt forgery). The signature scheme is free-form per the spec; ERC-1271 + EIP-712 typed-data is the recommended pattern.

Neo Equivalent: NEP-11 + Receipt Metadata Schema

NEP-11's Properties(tokenId) returns a Map; the receipt fields drop in directly. The receipt JSON typically lives off-chain (IPFS / HTTPS), with the on-chain Properties returning a URI plus the merchant signature for verification.

public static Map<string, object> Properties(ByteString tokenId)
{
    var props = base.Properties(tokenId);
    var receipt = (Map<string, object>)StdLib.Deserialize(
        (ByteString)Storage.Get(Storage.CurrentContext, ReceiptKey(tokenId)));
    if (receipt is not null)
    {
        props["receipt"] = receipt;
        props["merchantSignature"] = Storage.Get(Storage.CurrentContext, SigKey(tokenId));
    }
    return props;
}

public static void MintReceipt(
    UInt160 to, ByteString tokenId, Map<string, object> receipt,
    ECPoint merchantPubKey, ByteString merchantSig)
{
    if (!Runtime.CheckWitness(GetMerchant())) throw new Exception("RECEIPT:NotMerchant");
    var receiptBytes = StdLib.Serialize(receipt);
    if (!(bool)CryptoLib.VerifyWithECDsa(receiptBytes, merchantPubKey, merchantSig, NamedCurveHash.secp256r1SHA256))
        throw new Exception("RECEIPT:InvalidSignature");

    Storage.Put(Storage.CurrentContext, ReceiptKey(tokenId), receiptBytes);
    Storage.Put(Storage.CurrentContext, SigKey(tokenId),     merchantSig);
    Mint(tokenId, new TokenState { Owner = to });  // NEP-11 base: Mint(tokenId, TokenState)
}

ERC-5570 (Ethereum)	Neo Equivalent	Notes
Receipt JSON metadata	Map<string, object> stored serialised + URI	Same schema
Merchant signature (EIP-712 / ERC-1271)	secp256r1 signature verified at mint	On-chain verification
tokenURI(tokenId) returns receipt JSON	NEP-11 Properties(tokenId)["receipt"]	Direct port
Merchant identity	Stored merchant pubKey or contract hash	Verifiable provenance

Composition

• ERC-2981 — royalties. Merchants don't typically resell receipts, but if they do, royalties to the receipt issuer.
• ERC-2135 — consumable. Receipt redemption (e.g. a warranty claim) marks the receipt as consumed without burning.
• ERC-7066 — lockable. Lock receipts during a return-window dispute.
• ERC-3643 — T-REX. For receipts in regulated contexts (B2B invoices) requiring KYC.

Migration Notes

For POS / payment systems issuing ERC-5570 on Ethereum:

1. Receipt schema stays the same (it's a JSON convention).
2. Mint flow becomes a single Neo transaction: merchant signs the receipt JSON off-chain, calls MintReceipt(to, tokenId, receipt, pubKey, sig).
3. Wallets render the receipt by reading Properties(tokenId) and verifying the signature off-chain (or trusting the on-chain verification at mint time).

For accounting / tax software integrating receipt NFTs: the on-chain mint is the immutable record; off-chain processors read the standard schema for line-item + tax extraction.

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

contract ERC5570 {
    address public merchant;
    mapping(uint256 => string)  internal _receiptURI;
    mapping(uint256 => bytes)   internal _merchantSignature;
    mapping(uint256 => address) public ownerOf;

    event ReceiptMinted(uint256 indexed tokenId, address indexed buyer, string receiptURI);

    constructor() { merchant = msg.sender; }

    function mintReceipt(address to, uint256 tokenId, string calldata receiptURI, bytes calldata sig) external {
        require(msg.sender == merchant, "not merchant");
        ownerOf[tokenId]            = to;
        _receiptURI[tokenId]        = receiptURI;
        _merchantSignature[tokenId] = sig;
        emit ReceiptMinted(tokenId, to, receiptURI);
    }

    function tokenURI(uint256 tokenId) external view returns (string memory) {
        return _receiptURI[tokenId];
    }

    function merchantSignature(uint256 tokenId) external view returns (bytes memory) {
        return _merchantSignature[tokenId];
    }
}

using System;
using System.ComponentModel;
using Neo;
using Neo.Cryptography.ECC;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

[DisplayName("ReceiptNFT")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep11)]
public class ReceiptNFT : Nep11Token<TokenState>
{
    public override string Symbol => "RCPT";

    private const byte Prefix_Receipt = 0x20;
    private const byte Prefix_Sig     = 0x21;
    private const byte Prefix_PubKey  = 0x22;
    private const byte Prefix_Merchant = 0xff;

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

    [DisplayName("_deploy")]
    public static void Deploy(object data, bool update)
    {
        if (update) return;
        var args = (object[])data;
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Merchant }, (UInt160)args[0]);
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_PubKey   }, ((ECPoint)args[1]).EncodePoint(true));
    }

    public static void MintReceipt(UInt160 to, ByteString tokenId, ByteString receiptJson, ByteString sig)
    {
        var merchant = (UInt160)Storage.Get(Storage.CurrentContext, new byte[] { Prefix_Merchant });
        if (!Runtime.CheckWitness(merchant)) throw new Exception("RECEIPT:NotMerchant");

        var pubKey = (ECPoint)Storage.Get(Storage.CurrentContext, new byte[] { Prefix_PubKey });
        if (!(bool)CryptoLib.VerifyWithECDsa(receiptJson, pubKey, sig, NamedCurveHash.secp256r1SHA256))
            throw new Exception("RECEIPT:InvalidSignature");

        Storage.Put(Storage.CurrentContext, ReceiptKey(tokenId), receiptJson);
        Storage.Put(Storage.CurrentContext, SigKey(tokenId),     sig);
        Mint(tokenId, new TokenState { Owner = to });  // NEP-11 base: Mint(tokenId, TokenState)
        OnReceiptMinted(tokenId, to, receiptJson);
    }

    public static ByteString GetReceipt(ByteString tokenId)
        => (ByteString)Storage.Get(Storage.CurrentContext, ReceiptKey(tokenId));

    public static ByteString MerchantSignature(ByteString tokenId)
        => (ByteString)Storage.Get(Storage.CurrentContext, SigKey(tokenId));

    private static byte[] ReceiptKey(ByteString tokenId) => new byte[] { Prefix_Receipt }.Concat(tokenId);
    private static byte[] SigKey(ByteString tokenId)     => new byte[] { Prefix_Sig     }.Concat(tokenId);
}

Wallet UX

Wallets render a receipt NFT by parsing the receipt field from Properties and showing line items, totals, and a verification badge based on the merchant signature check. Returns / warranty flows can follow up with Consume(tokenId) per the ERC-2135 mirror to mark the receipt as redeemed without destroying the proof-of-purchase.