ERC-6909 — Minimal Multi-Token

Back to Token Standards

ERC-6909: Minimal Multi-Token Standard

ERC-6909 is a leaner alternative to ERC-1155 that strips out the safe-transfer acceptance check (no recipient hooks at all), removes the URI requirement, and simplifies operator approvals. Used by Uniswap V4's pool manager — every pool's liquidity is represented as a separate ERC-6909 token id.

Required Interface

function balanceOf(address owner, uint256 id) external view returns (uint256);
function transfer(address to, uint256 id, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 id, uint256 amount)
    external returns (bool);
function approve(address spender, uint256 id, uint256 amount) external returns (bool);
function allowance(address owner, address spender, uint256 id) external view returns (uint256);
function setOperator(address operator, bool approved) external returns (bool);
function isOperator(address owner, address operator) external view returns (bool);

Neo Equivalent: Direct Port

The Neo C# port replaces approve/allowance with witness checks (default Neo authorization). Operators map to NEP-30-style authorisation contracts but for the common case the witness model already covers it.

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

contract ERC6909 {
    mapping(address => mapping(uint256 => uint256)) public balanceOf;
    mapping(address => mapping(address => mapping(uint256 => uint256))) public allowance;
    mapping(address => mapping(address => bool)) public isOperator;

    event Transfer(address caller, address indexed from, address indexed to,
                   uint256 indexed id, uint256 amount);
    event Approval(address indexed owner, address indexed spender,
                   uint256 indexed id, uint256 amount);
    event OperatorSet(address indexed owner, address indexed operator, bool approved);

    function transfer(address to, uint256 id, uint256 amount) public returns (bool) {
        balanceOf[msg.sender][id] -= amount;
        balanceOf[to][id]         += amount;
        emit Transfer(msg.sender, msg.sender, to, id, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 id, uint256 amount)
        public returns (bool)
    {
        if (msg.sender != from && !isOperator[from][msg.sender]) {
            uint256 allowed = allowance[from][msg.sender][id];
            if (allowed != type(uint256).max) {
                allowance[from][msg.sender][id] = allowed - amount;
            }
        }
        balanceOf[from][id] -= amount;
        balanceOf[to][id]   += amount;
        emit Transfer(msg.sender, from, to, id, amount);
        return true;
    }

    function approve(address spender, uint256 id, uint256 amount) public returns (bool) {
        allowance[msg.sender][spender][id] = amount;
        emit Approval(msg.sender, spender, id, amount);
        return true;
    }

    function setOperator(address operator, bool approved) public returns (bool) {
        isOperator[msg.sender][operator] = approved;
        emit OperatorSet(msg.sender, operator, approved);
        return true;
    }
}

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("MinimalMultiToken")]
[ContractPermission("*", "*")]
public class MinimalMultiToken : SmartContract
{
    private const byte Prefix_Balance = 0x01;  // owner+id -> amount

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

    public static BigInteger BalanceOf(UInt160 owner, ByteString id)
        => (BigInteger)(Storage.Get(Storage.CurrentContext,
            new byte[] { Prefix_Balance }.Concat(owner).Concat(id)) ?? ByteString.Empty);

    public static bool Transfer(UInt160 from, UInt160 to, ByteString id, BigInteger amount)
    {
        if (!Runtime.CheckWitness(from)) throw new Exception("no authorization");
        if (amount < 0)                  throw new Exception("amount < 0");

        var fromBal = BalanceOf(from, id);
        if (fromBal < amount) return false;
        UpdateBalance(from, id, fromBal - amount);
        UpdateBalance(to,   id, BalanceOf(to, id) + amount);
        OnTransfer(Runtime.CallingScriptHash, from, to, id, amount);
        return true;
    }

    private static void UpdateBalance(UInt160 owner, ByteString id, BigInteger value)
    {
        var key = new byte[] { Prefix_Balance }.Concat(owner).Concat(id);
        if (value == 0) Storage.Delete(Storage.CurrentContext, key);
        else            Storage.Put(Storage.CurrentContext, key, value);
    }

    public static void Mint(UInt160 to, ByteString id, BigInteger amount)
    {
        if (!Runtime.CheckWitness(GetAdmin())) throw new Exception("admin only");
        UpdateBalance(to, id, BalanceOf(to, id) + amount);
        OnTransfer(Runtime.CallingScriptHash, UInt160.Zero, to, id, amount);
    }

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

Why It's Cleaner on Neo

The witness model removes ERC-6909's allowance and setOperator complexity. A caller that wants to spend on behalf of from simply needs from to be a signer of the transaction with an appropriate witness scope. No per-id allowance storage, no operator booleans.