Blockchain Smart Contracts with Solidity · Lesson

ERC-1155 Multi-Token Standard

Learn the ERC-1155 multi-token standard that lets a single contract manage fungible, semi-fungible, and non-fungible tokens together for gas-efficient batch operations.

ERC-1155 Multi-Token Standard is a free Blockchain Smart Contracts with Solidity lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Blockchain Smart Contracts with Solidity learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Why ERC-1155 Exists

ERC-20 manages one fungible token; ERC-721 manages unique NFTs. But a game may need thousands of item types mixing both. Deploying a separate contract per type is wasteful.

ERC-1155 is a single contract that can manage many token IDs at once, each of which can be fungible or non-fungible.

Token IDs as Categories

In ERC-1155 each token is identified by a numeric id. The same id can have a balance greater than one (fungible) or a supply of exactly one (non-fungible).

id = 1 with balance 500 = a fungible gold coin
id = 2 with balance 1 = a unique sword NFT

Core Balance Mapping

The heart of an ERC-1155 contract is a nested mapping from id to owner to balance.

mapping(uint256 => mapping(address => uint256)) private _balances;

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

Batch Balance Queries

A signature feature is balanceOfBatch, which returns many balances in one call, saving round trips.

function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
    public view returns (uint256[] memory)
{
    require(accounts.length == ids.length, 'length mismatch');
    uint256[] memory batch = new uint256[](accounts.length);
    for (uint256 i = 0; i < accounts.length; i++) {
        batch[i] = _balances[ids[i]][accounts[i]];
    }
    return batch;
}

Batch Transfers

ERC-1155 lets you move several token types in a single transaction with safeBatchTransferFrom. This is far cheaper than many separate ERC-20/721 transfers.

function safeBatchTransferFrom(
    address from,
    address to,
    uint256[] memory ids,
    uint256[] memory amounts,
    bytes memory data
) public {
    require(ids.length == amounts.length, 'length mismatch');
    for (uint256 i = 0; i < ids.length; i++) {
        _balances[ids[i]][from] -= amounts[i];
        _balances[ids[i]][to] += amounts[i];
    }
}

Approval For All

Instead of per-token approvals, ERC-1155 uses a single operator approval: setApprovalForAll grants an address permission to move every token you own.

mapping(address => mapping(address => bool)) private _operatorApprovals;

function setApprovalForAll(address operator, bool approved) public {
    _operatorApprovals[msg.sender][operator] = approved;
}

function isApprovedForAll(address owner, address operator) public view returns (bool) {
    return _operatorApprovals[owner][operator];
}

The Shared Metadata URI

ERC-1155 uses one URI template for all tokens. The placeholder {id} is replaced by the hex token id by clients.

Example: https://game.example/api/{id}.json

string private _uri = 'https://game.example/api/{id}.json';

function uri(uint256) public view returns (string memory) {
    return _uri;
}

Minting Tokens

Minting increases a balance for an id. The same internal logic works for both fungible (amount > 1) and non-fungible (amount = 1) tokens.

function _mint(address to, uint256 id, uint256 amount) internal {
    require(to != address(0), 'mint to zero');
    _balances[id][to] += amount;
    emit TransferSingle(msg.sender, address(0), to, id, amount);
}

event TransferSingle(address operator, address from, address to, uint256 id, uint256 value);

Safe Transfer Receiver Check

Like ERC-721, ERC-1155 protects against tokens being locked in contracts. A receiving contract must implement onERC1155Received and return its magic value, or the transfer reverts.

interface IERC1155Receiver {
    function onERC1155Received(
        address operator, address from,
        uint256 id, uint256 value, bytes calldata data
    ) external returns (bytes4);
}

Using OpenZeppelin

In practice you inherit the audited OpenZeppelin implementation rather than writing it from scratch.

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

import '@openzeppelin/contracts/token/ERC1155/ERC1155.sol';

contract GameItems is ERC1155 {
    uint256 public constant GOLD = 0;
    uint256 public constant SWORD = 1;

    constructor() ERC1155('https://game.example/api/{id}.json') {
        _mint(msg.sender, GOLD, 1000, '');
        _mint(msg.sender, SWORD, 1, '');
    }
}

When To Choose ERC-1155

Pick ERC-1155 when you have many token types, need batch operations, or mix fungible and non-fungible assets. Stick with ERC-20/721 for a single, simple asset where the extra complexity is not justified.

Quick Check

Test your understanding of ERC-1155.

Recap

You learned that ERC-1155 is a multi-token standard managing many IDs in one contract. Key points:

Nested id => owner => balance mapping
Batch queries and transfers save gas
Single operator approval and shared {id} URI
Safe-transfer receiver checks protect against locked tokens

It is the standard of choice for games and marketplaces with many asset types.

Frequently asked questions

Is the “ERC-1155 Multi-Token Standard” lesson free?

Yes — the full text of “ERC-1155 Multi-Token Standard” is free to read here on the web, and the Blockchain Smart Contracts with Solidity course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Blockchain Smart Contracts with Solidity course, upgrade to CoddyKit PRO.

What will I learn in “ERC-1155 Multi-Token Standard”?

Learn the ERC-1155 multi-token standard that lets a single contract manage fungible, semi-fungible, and non-fungible tokens together for gas-efficient batch operations. You practise Blockchain Smart Contracts with Solidity with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Blockchain Smart Contracts with Solidity?

No prior experience is required. Blockchain Smart Contracts with Solidity on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “ERC-1155 Multi-Token Standard” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Blockchain Smart Contracts with Solidity lesson?

Yes. Every Blockchain Smart Contracts with Solidity lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Blockchain Smart Contracts with Solidity