ERC-1155 — Multi-Token

Back to Token Standards

ERC-1155: Multi-Token Standard

ERC-1155 packs both fungible and non-fungible token types into a single contract. Originally built for gaming (one contract holds 1000 different sword types + a fungible gold currency), it's now common across DeFi for batch operations.

Neo Approach: Composition

There is no dedicated multi-token NEP. Instead, Neo recommends composition: deploy a single NEP-17 per fungible type, use NEP-11 with decimals() > 0 for divisible non-fungibles. Batch transfers compose at the application layer — Neo's multi-call transaction format lets one signed tx invoke many contracts atomically.

For a true multi-token use case in a single contract, the C# tab below shows a Neo port of ERC-1155 — works, but composition is usually cleaner.

Live on Neo TestNet

Both implementations deployed on Neo N3 TestNet.

Implementation	TestNet Address	Contract Hash
Solidity (neo-solc)	Nh1cqvGbsjE3FFhuZRWMytSskeYqs1FTPb	0xf1d7867c…224d0317
Neo C# (nccs)	Nh4WdHEoVHQiBL3GoCfM98AkWMnwqumFW6	0xef019e6f…a8ba86bd

Verified: deployer claim, ownership semantics. Per-id balance and batch transfer flows validated by the assertion script in deployments/manifest.json. docs/standards-mirror/deployments/erc-1155/.

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

contract ERC1155 {
    mapping(uint256 => mapping(address => uint256)) private _balance;
    mapping(address => mapping(address => bool))    private _operator;
    string private _baseURI;

    event TransferSingle(address operator, address from, address to,
                         uint256 id, uint256 value);
    event TransferBatch (address operator, address from, address to,
                         uint256[] ids, uint256[] values);
    event ApprovalForAll(address account, address operator, bool approved);

    function balanceOf(address account, uint256 id) public view returns (uint256) {
        return _balance[id][account];
    }

    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        public view returns (uint256[] memory)
    {
        require(accounts.length == ids.length, "len");
        uint256[] memory out = new uint256[](accounts.length);
        for (uint i; i < accounts.length; ++i) out[i] = _balance[ids[i]][accounts[i]];
        return out;
    }

    function setApprovalForAll(address op, bool approved) public {
        _operator[msg.sender][op] = approved;
        emit ApprovalForAll(msg.sender, op, approved);
    }

    function safeTransferFrom(
        address from, address to, uint256 id, uint256 amount, bytes calldata data
    ) public {
        require(from == msg.sender || _operator[from][msg.sender], "auth");
        _balance[id][from] -= amount;
        _balance[id][to]   += amount;
        emit TransferSingle(msg.sender, from, to, id, amount);
    }

    function safeBatchTransferFrom(
        address from, address to, uint256[] calldata ids,
        uint256[] calldata amounts, bytes calldata data
    ) public {
        require(from == msg.sender || _operator[from][msg.sender], "auth");
        require(ids.length == amounts.length, "len");
        for (uint i; i < ids.length; ++i) {
            _balance[ids[i]][from] -= amounts[i];
            _balance[ids[i]][to]   += amounts[i];
        }
        emit TransferBatch(msg.sender, from, to, ids, amounts);
    }
}

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

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

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

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

    public static BigInteger[] BalanceOfBatch(UInt160[] accounts, ByteString[] ids)
    {
        if (accounts.Length != ids.Length) throw new Exception("length mismatch");
        var output = new BigInteger[accounts.Length];
        for (int i = 0; i < accounts.Length; i++)
            output[i] = BalanceOf(accounts[i], ids[i]);
        return output;
    }

    public static bool TransferSingle(UInt160 from, UInt160 to, ByteString id,
                                      BigInteger amount, object data)
    {
        if (!Runtime.CheckWitness(from)) throw new Exception("no authorization");
        var bal = BalanceOf(from, id);
        if (bal < amount) return false;

        UpdateBalance(from, id, bal - amount);
        UpdateBalance(to,   id, BalanceOf(to, id) + amount);
        OnTransferSingle(Runtime.CallingScriptHash, from, to, id, amount);

        if (ContractManagement.GetContract(to) != null)
            Contract.Call(to, "onNEP17Payment", CallFlags.All,
                new object[] { from, amount, data });
        return true;
    }

    public static bool TransferBatch(UInt160 from, UInt160 to, ByteString[] ids,
                                     BigInteger[] amounts, object data)
    {
        if (!Runtime.CheckWitness(from))   throw new Exception("no authorization");
        if (ids.Length != amounts.Length)  throw new Exception("length mismatch");

        for (int i = 0; i < ids.Length; i++)
        {
            var bal = BalanceOf(from, ids[i]);
            if (bal < amounts[i]) throw new Exception("insufficient");
            UpdateBalance(from, ids[i], bal - amounts[i]);
            UpdateBalance(to,   ids[i], BalanceOf(to, ids[i]) + amounts[i]);
        }
        OnTransferBatch(Runtime.CallingScriptHash, from, to, ids, amounts);
        return true;
    }

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