ERC-2309 — Consecutive NFT Mints

Back to Token Standards

ERC-2309: Consecutive Transfer Event

A gas-optimization standard: instead of emitting one Transfer event per token in a batch mint, emit a single ConsecutiveTransfer(fromId, toId, fromAddr, toAddr) event covering the entire range. Indexers (TheGraph, OpenSea) parse this and synthesize per-token transfers off-chain.

Required Event

event ConsecutiveTransfer(
    uint256 indexed fromTokenId,
    uint256 toTokenId,
    address indexed fromAddress,
    address indexed toAddress
);

Neo Equivalent: Same Event Pattern

Neo's event system supports identical semantics — emit one event covering a range instead of N events. Below is the Neo C# port. The event signature is named ConsecutiveTransfer and indexers can subscribe to it just as they would on Ethereum.

Live on Neo TestNet

Both implementations are deployed on Neo N3 TestNet (network magic 894710606).

Implementation	Contract Hash	Deploy Tx
Solidity (neo-solc)	0x20262b3b96d92a0db7bfdc4782903fb3d997f900	0x014b746a…f4fd44
Neo C# (nccs)	0x2e157ce2532dee6084f53c1a848975bd960be918	0x60d5dcf1…7d1bd2

Cross-implementation invocations match on claimDeployer, totalMinted, getDeployer. Source pairs under docs/standards-mirror/deployments/erc-2309/.

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

contract ERC721A {
    mapping(uint256 => address) private _explicitOwner;
    mapping(address => uint256) private _balance;
    uint256 private _next;

    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event ConsecutiveTransfer(
        uint256 indexed fromTokenId, uint256 toTokenId,
        address indexed fromAddress, address indexed toAddress
    );

    function mintBatch(address to, uint256 count) external {
        uint256 fromId = _next;
        uint256 toId   = _next + count - 1;
        _next         += count;
        _balance[to]  += count;
        _explicitOwner[fromId] = to;   // sentinel — fill rest lazily on first transfer
        emit ConsecutiveTransfer(fromId, toId, address(0), to);
    }

    function ownerOf(uint256 tokenId) public view returns (address) {
        // Walk back from tokenId to find the most recent explicit owner.
        for (uint256 i = tokenId; i >= 0; --i) {
            if (_explicitOwner[i] != address(0)) return _explicitOwner[i];
            if (i == 0) break;
        }
        revert("nonexistent");
    }
}

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("BatchMintNFT")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep11)]
public class BatchMintNFT : SmartContract
{
    private const byte Prefix_Explicit = 0x01;   // explicit owner records
    private const byte Prefix_Balance  = 0x02;
    private static readonly byte[] NextIdKey = { 0xFE };

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

    [DisplayName("ConsecutiveTransfer")]
    public static event Action<BigInteger, BigInteger, UInt160, UInt160> OnConsecutiveTransfer;

    public static void MintBatch(UInt160 to, BigInteger count)
    {
        if (!Runtime.CheckWitness(GetAdmin())) throw new Exception("admin only");
        if (count <= 0) throw new Exception("count <= 0");

        var fromId = (BigInteger)(Storage.Get(Storage.CurrentContext, NextIdKey) ?? ByteString.Empty);
        var toId   = fromId + count - 1;
        Storage.Put(Storage.CurrentContext, NextIdKey, toId + 1);

        // Single sentinel record for the whole range
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Explicit }.Concat(((ByteString)fromId.ToByteArray())),
                    to);

        var bal = (BigInteger)(Storage.Get(Storage.CurrentContext,
                                           new byte[] { Prefix_Balance }.Concat(to))
                               ?? ByteString.Empty) + count;
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Balance }.Concat(to), bal);

        OnConsecutiveTransfer(fromId, toId, UInt160.Zero, to);
    }

    public static UInt160 OwnerOf(ByteString tokenIdBytes)
    {
        var tokenId = new BigInteger(tokenIdBytes);
        // Iterate explicit owner records, walk back from tokenId
        var iter = Storage.Find(Storage.CurrentContext, new byte[] { Prefix_Explicit },
                                FindOptions.None);
        UInt160 best = null;
        BigInteger bestId = -1;
        while (iter.Next())
        {
            var entry = (object[])iter.Value;
            var id    = new BigInteger((ByteString)entry[0]);
            var owner = (UInt160)entry[1];
            if (id <= tokenId && id > bestId) { bestId = id; best = owner; }
        }
        if (best == null) throw new Exception("nonexistent");
        return best;
    }

    private static UInt160 GetAdmin() => (UInt160)"0x0000000000000000000000000000000000000000";
}