ERC-5679 — Token Minting and Burning

Back to Token Standards

ERC-5679: Token Minting and Burning

ERC-5679 standardises the mint and burn function surfaces across ERC-20, ERC-721, and ERC-1155. Pre-5679, every token shipped its own naming (mint / _mint / mintTo / safeMint / …) and own authorization model. The ERC picks one signature per standard and asks implementations to converge:

// ERC-20 / ERC-1155
interface IERC5679Mint {
    function mint(address to, uint256 amountOrId, bytes calldata data) external;
}
interface IERC5679Burn {
    function burn(address from, uint256 amountOrId, bytes calldata data) external;
}

// ERC-721 (no amount, just tokenId)
interface IERC5679Mint721 {
    function safeMint(address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC5679Burn721 {
    function burn(address from, uint256 tokenId, bytes calldata data) external;
}

Indexers, asset-explorers, and inventory tools can recognise these selectors uniformly across token types. The data parameter is opaque to the spec — typically used for IPFS metadata pointers, off-chain proof hashes, or empty.

Neo Equivalent: NEP-17 / NEP-11 Mint Helper Convention

Neo's NEP-17 and NEP-11 base classes already include Mint and Burn internal helpers — most production tokens expose them via thin public wrappers. ERC-5679 is the formalisation of that wrapper shape. This mirror page proposes a Neo equivalent vocabulary (paired with the ERC-6093 error vocabulary):

ERC-5679 (Ethereum)	Neo Equivalent	Notes
IERC5679Mint.mint(to, amount, data) (ERC-20)	Mint(UInt160 to, BigInteger amount, object data) on NEP-17	NEP-17 base provides internal Mint; expose via public wrapper
IERC5679Burn.burn(from, amount, data) (ERC-20)	Burn(UInt160 from, BigInteger amount, object data) on NEP-17	Witness-checked on from; gates by admin or holder
IERC5679Mint721.safeMint(to, tokenId, data)	Mint(UInt160 to, ByteString tokenId, object data) on NEP-11	Includes tokenId; data flows to recipient's OnNEP11Payment
IERC5679Burn721.burn(from, tokenId, data)	Burn(UInt160 from, ByteString tokenId, object data) on NEP-11	Witness-checked on from
ERC-1155 (amount + id)	Mint(UInt160 to, ByteString tokenId, BigInteger amount, object data) on a NEP-11 divisible	Combined shape

The "data" Parameter

ERC-5679 leaves data opaque. Typical use:

• NFT metadata — IPFS CID or HTTPS metadata URL appended at mint; the contract stores it for tokenURI(tokenId).
• Mint authorisation proof — off-chain signature from a permitted minter, verified inside Mint.
• Inflation rationale — encoded reason string for governance audit trails on stablecoin / RWA mints.

On Neo, the same data becomes the third argument to OnNEP17Payment / OnNEP11Payment if the recipient is a contract, so the parameter threads through the existing callback flow — no extra plumbing.

Authorization

ERC-5679 explicitly does not standardise who can call mint/burn. Implementations choose: a single owner (ERC-173), a role (AccessControl roles), a multisig, governance, etc. The Neo equivalent is the same: Runtime.CheckWitness(authorisedMinter) where authorisedMinter comes from whatever the contract's authorization model is.

Migration Notes

For Solidity contracts using OpenZeppelin's _mint / _burn:

1. Replace _mint/_burn with the public ERC-5679 selectors if you want indexer-friendly external minting.
2. For Neo C# ports, expose Mint(to, amount, data) and Burn(from, amount, data) as thin wrappers around the inherited internal Mint / Burn. Witness-check the caller against the contract's owner / minter-role storage.
3. For neo-solc ports, the Solidity mint / burn shape compiles cleanly; the data parameter is ignored if not used. For NEP-17 wrappers, route the data argument into the recipient's OnNEP17Payment callback for full ERC-5679 compatibility.

Why The Mirror Matters

NEP-17 / NEP-11 base classes already provide internal Mint / Burn, but the public surface varies wildly across deployed Neo tokens (Issue, MintTo, MintAndCall, …). Adopting the ERC-5679 vocabulary gives indexers one selector to look for, regardless of whether the token was authored in C# or via neo-solc.

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

interface IERC5679Mint20 {
    function mint(address to, uint256 amount, bytes calldata data) external;
}
interface IERC5679Burn20 {
    function burn(address from, uint256 amount, bytes calldata data) external;
}

contract Mintable20 is IERC5679Mint20, IERC5679Burn20 {
    address public owner;
    mapping(address => uint256) public balanceOf;
    uint256 public totalSupply;

    event Transfer(address indexed from, address indexed to, uint256 amount);

    modifier onlyOwner() { require(msg.sender == owner, "owner only"); _; }

    function mint(address to, uint256 amount, bytes calldata /*data*/) external onlyOwner {
        balanceOf[to] += amount;
        totalSupply   += amount;
        emit Transfer(address(0), to, amount);
    }

    function burn(address from, uint256 amount, bytes calldata /*data*/) external onlyOwner {
        balanceOf[from] -= amount;
        totalSupply     -= amount;
        emit Transfer(from, address(0), amount);
    }
}

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("Mintable")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep17)]
public class Mintable : Nep17Token
{
    public override string Symbol  => "MINT";
    public override byte   Decimals => 8;

    private const byte Prefix_Owner = 0xff;

    [DisplayName("_deploy")]
    public static void Deploy(object data, bool update)
    {
        if (update) return;
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Owner }, (UInt160)data);
    }

    public static UInt160 Owner()
        => (UInt160)Storage.Get(Storage.CurrentContext, new byte[] { Prefix_Owner });

    /// ERC-5679 mint selector — public wrapper around the inherited Mint helper.
    /// `data` flows to the recipient's OnNEP17Payment callback per NEP-17 semantics.
    public static void Mint(UInt160 to, BigInteger amount, object data)
    {
        if (!Runtime.CheckWitness(Owner())) throw new Exception("NEP17:NotMinter");
        if (amount <= 0)                    throw new Exception("NEP17:AmountNonPositive");
        Mint(to, amount);
        // NEP-17 callback already fires inside the base Transfer; OnNEP17Payment
        // on `to` will receive `data` as its third argument.
    }

    /// ERC-5679 burn selector — gated by holder witness or minter authority.
    public static void Burn(UInt160 from, BigInteger amount, object data)
    {
        var caller = Owner();
        if (!Runtime.CheckWitness(from) && !Runtime.CheckWitness(caller))
            throw new Exception("NEP17:NoAuth");
        Burn(from, amount);
    }
}

Adopt-or-Migrate Choice

For greenfield Neo tokens: adopt the Mint(to, amount, data) and Burn(from, amount, data) selectors from day one. Pair with the ERC-6093 error vocabulary for a fully indexer-friendly shape.

For existing tokens: add the ERC-5679 selectors as new wrappers next to your existing Issue / MintTo / etc. methods — keep the old methods for backward compatibility, point new clients at the standardised selectors.