EIP-1155ERC代币标准Final（2018-06-17）

多代币标准

一个合约同时管理多种代币：同质化与非同质化可以共存，支持批量转移，游戏道具场景的首选。

适用链：全部 EVM 链 + 各 L2

为什么重要：ERC-1155 把「同一批道具的 1000 份」表示为同一个 id 的余额，而不是 1000 个 NFT。这使得批量空投、批量转移的 Gas 从 O(n) 降到接近 O(1)，是链游与票务的标准做法。

函数签名与选择器

选择器是签名的 keccak256 前 4 字节；事件则是完整的 32 字节 topic0。点一下即可复制。

签名 / 字段	选择器 / topic0	说明
balanceOf(address,uint256)		某地址持有某个 id 的数量。
balanceOfBatch(address[],uint256[])		批量查询，两个数组长度必须相等。
setApprovalForAll(address,bool)		授权操作者管理全部代币种类。
isApprovedForAll(address,address)		查询全局授权。
safeTransferFrom(address,address,uint256,uint256,bytes)		from / to / id / amount / data 五个参数。
safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)		批量转移：ids 与 amounts 数组一一对应，这是它相对 721 最大的优势。
event URI(string,uint256)事件		id 的元数据地址变更时发出。
event TransferSingle(address,address,address,uint256,uint256)事件		单笔转移事件，operator 是实际执行者。
event TransferBatch(address,address,address,uint256[],uint256[])事件		批量转移事件，索引器需要按数组展开处理。

代码模板

最小实现（单笔 + 批量转移）

最小实现（单笔 + 批量转移）Solidity

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

interface IERC1155Receiver {
    function onERC1155Received(address, address, uint256, uint256, bytes calldata)
        external returns (bytes4);
    function onERC1155BatchReceived(address, address, uint256[] calldata, uint256[] calldata, bytes calldata)
        external returns (bytes4);
}

contract MinimalERC1155 {
    mapping(uint256 => mapping(address => uint256)) private _balances;
    mapping(address => mapping(address => bool)) private _operatorApprovals;
    mapping(uint256 => uint256) public totalSupply;

    string private _uri = "ipfs://bafy.../{id}.json";

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

    error LengthMismatch();
    error InsufficientBalance(uint256 available, uint256 required);
    error ZeroAddress();
    error NotAuthorized();
    error UnsafeRecipient();

    function balanceOf(address owner, uint256 id) public view returns (uint256) {
        if (owner == address(0)) revert ZeroAddress();
        return _balances[id][owner];
    }

    function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
        external view returns (uint256[] memory)
    {
        if (owners.length != ids.length) revert LengthMismatch();

        uint256[] memory out = new uint256[](owners.length);
        for (uint256 i = 0; i < owners.length; i++) {
            out[i] = _balances[ids[i]][owners[i]];
        }
        return out;
    }

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

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

    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data)
        external
    {
        if (msg.sender != from && !_operatorApprovals[from][msg.sender]) revert NotAuthorized();
        _safeTransfer(from, to, id, amount, data);
        emit TransferSingle(msg.sender, from, to, id, amount);
    }

    function safeBatchTransferFrom(
        address from, address to,
        uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data
    ) external {
        if (msg.sender != from && !_operatorApprovals[from][msg.sender]) revert NotAuthorized();
        if (ids.length != amounts.length) revert LengthMismatch();

        for (uint256 i = 0; i < ids.length; i++) {
            _safeTransfer(from, to, ids[i], amounts[i], "");
        }

        if (to.code.length > 0) {
            if (
                IERC1155Receiver(to).onERC1155BatchReceived(msg.sender, from, ids, amounts, data)
                    != IERC1155Receiver.onERC1155BatchReceived.selector
            ) revert UnsafeRecipient();
        }

        emit TransferBatch(msg.sender, from, to, ids, amounts);
    }

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

    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
        // 0xd9b67a26 = ERC-1155, 0x0e89341c = Metadata URI, 0x01ffc9a7 = EIP-165
        return interfaceId == 0xd9b67a26 || interfaceId == 0x0e89341c || interfaceId == 0x01ffc9a7;
    }

    function _safeTransfer(address from, address to, uint256 id, uint256 amount, bytes memory data) internal {
        if (to == address(0)) revert ZeroAddress();

        uint256 bal = _balances[id][from];
        if (bal < amount) revert InsufficientBalance(bal, amount);

        unchecked {
            _balances[id][from] = bal - amount;
            _balances[id][to] += amount;
        }

        if (to.code.length > 0) {
            if (
                IERC1155Receiver(to).onERC1155Received(msg.sender, from, id, amount, data)
                    != IERC1155Receiver.onERC1155Received.selector
            ) revert UnsafeRecipient();
        }
    }
}

批量转移时 receiver 回调只调一次（onERC1155BatchReceived），而不是每个 id 调一次，这是省 Gas 的关键。

批量空投的调用方式（viem）

批量空投的调用方式（viem）TypeScript

import { parseAbi } from 'viem';

const abi = parseAbi([
  'function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] amounts, bytes data)',
]);

// 一次交易给一个用户发 20 种道具，Gas 远低于 20 笔独立交易
const ids = Array.from({ length: 20 }, (_, i) => BigInt(i + 1));
const amounts = ids.map(() => 1n);

const hash = await wallet.writeContract({
  account,
  address: ITEM_CONTRACT,
  abi,
  functionName: 'safeBatchTransferFrom',
  args: [treasury, player, ids, amounts, '0x'],
});

await client.waitForTransactionReceipt({ hash });

实现与使用时的常见陷阱

✕ids 与 amounts 数组长度必须一致，否则必须 revert——漏掉这个检查会让索引器算错余额。
✕是否用 ERC-1155 的判断依据：同一批资产需要发多份（道具、票、材料）。如果每份都独一无二且需要独立元数据，用 ERC-721。
✕部分市场对 ERC-1155 的支持弱于 721，做 PFP 类项目不建议用它。
✕uri 里的 {id} 是十六进制、64 位补齐的字符串（OpenZeppelin 的惯例），自己实现时要确认前端替换逻辑一致。
✕批量转移的 receiver 回调必须返回正确的 selector，否则整批回滚。

多代币标准

函数签名与选择器

代码模板

实现与使用时的常见陷阱

相关标准