ERC-1155: one contract, many tokens

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

// The heart of ERC-1155: a balance is indexed by BOTH a token id AND an owner,
// so ONE contract can hold every kind of token a game (or app) needs.
interface IERC1155 {
    // ERC-20 asks balanceOf(owner); ERC-721 asks ownerOf(tokenId).
    // ERC-1155 fuses them: how many of token `id` does `account` hold?
    function balanceOf(address account, uint256 id) external view returns (uint256);
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external view returns (uint256[] memory);

    // No per-token approve: you grant an operator ALL of your token types at once.
    function setApprovalForAll(address operator, bool approved) external;
    function isApprovedForAll(address account, address operator) external view returns (bool);

    function safeTransferFrom(
        address from, address to, uint256 id, uint256 value, bytes calldata data
    ) external;
    function safeBatchTransferFrom(
        address from, address to,
        uint256[] calldata ids, uint256[] calldata values, bytes calldata data
    ) external;

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

// A simplified game-item contract. In production you would inherit
// OpenZeppelin's audited ERC1155 instead of hand-rolling the ledger.
contract GameItems {
    // id => (owner => amount): the whole fungible + non-fungible ledger in one map.
    mapping(uint256 => mapping(address => uint256)) public balanceOf;
    mapping(address => mapping(address => bool))   public isApprovedForAll;

    uint256 public constant GOLD  = 1; // fungible: 1000 identical coins
    uint256 public constant SWORD = 2; // non-fungible: total supply of exactly 1

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

    constructor() {
        // Mint both token types from the SAME contract to the deployer.
        balanceOf[GOLD][msg.sender]  = 1000;
        balanceOf[SWORD][msg.sender] = 1;
        // ERC-1155 signals a mint as a transfer FROM the zero address.
        emit TransferSingle(msg.sender, address(0), msg.sender, GOLD, 1000);
        emit TransferSingle(msg.sender, address(0), msg.sender, SWORD, 1);
    }
}

// Move many token types in ONE atomic transaction:
// e.g. sell {SWORD x1, GOLD x50, POTION x3} as a single bundle.
function safeBatchTransferFrom(
    address from,
    address to,
    uint256[] calldata ids,
    uint256[] calldata values,
    bytes calldata data
) external {
    require(to != address(0), "transfer to zero address");
    require(ids.length == values.length, "ids/values length mismatch");
    require(from == msg.sender || isApprovedForAll[from][msg.sender], "not authorized");

    for (uint256 i = 0; i < ids.length; ++i) {
        balanceOf[ids[i]][from] -= values[i]; // reverts on underflow in 0.8+
        balanceOf[ids[i]][to]   += values[i];
    }
    emit TransferBatch(msg.sender, from, to, ids, values);

    // If the recipient is a contract, it MUST acknowledge the batch or we revert.
    if (to.code.length > 0) {
        require(
            IERC1155Receiver(to).onERC1155BatchReceived(msg.sender, from, ids, values, data)
                == IERC1155Receiver.onERC1155BatchReceived.selector,
            "unsafe recipient: not an ERC-1155 receiver"
        );
    }
}

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

    function onERC1155BatchReceived(
        address operator, address from,
        uint256[] calldata ids, uint256[] calldata values, bytes calldata data
    ) external returns (bytes4);
}

// A vault willing to custody game items must return the exact magic value,
// otherwise every safe(Batch)TransferFrom into it reverts and the tokens stay put.
contract ItemVault is IERC1155Receiver {
    function onERC1155Received(address, address, uint256, uint256, bytes calldata)
        external pure returns (bytes4)
    {
        return this.onERC1155Received.selector;      // 0xf23a6e61
    }
    function onERC1155BatchReceived(address, address, uint256[] calldata, uint256[] calldata, bytes calldata)
        external pure returns (bytes4)
    {
        return this.onERC1155BatchReceived.selector; // 0xbc197c81
    }
}

// ONE URI template serves EVERY token id (the ERC-1155 metadata extension):
uri = "https://game.example/api/item/{id}.json"

// Clients replace the literal "{id}" with the LOWERCASE hex id,
// zero-padded to 64 characters, with NO 0x prefix.
// For GOLD (id = 1):
//   {id} -> 0000000000000000000000000000000000000000000000000000000000000001
// Resolved metadata URL:
//   https://game.example/api/item/000...0001.json
//
// One template, no per-token storage write -> cheap metadata for millions of ids.