// SPDX-License-Identifier: MIT pragma solidity ^0.8.35; import { IERC1155Receiver } from '../../interfaces/IERC1155Receiver.sol'; import { _Introspectable } from '../../introspection/_Introspectable.sol'; import { _Context } from '../../meta/_Context.sol'; import { ERC1155Storage } from '../../storage/ERC1155Storage.sol'; import { Address } from '../../utils/Address.sol'; import { _IMultiToken } from './_IMultiToken.sol'; /** * @title Base MultiToken internal functions * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts/ (MIT license) */ abstract contract _MultiToken is _IMultiToken, _Introspectable, _Context { using Address for address; /** * @notice query the balance of given token held by given address * @param account address to query * @param id token to query * @return token balance */ function _balanceOf( address account, uint256 id ) internal view virtual returns (uint256) { if (account == address(0)) revert MultiToken__BalanceQueryZeroAddress(); return ERC1155Storage.ref(ERC1155Storage.DEFAULT_STORAGE_SLOT).balances[ id ][account]; } /** * @notice query the balances of given tokens held by given addresses * @param accounts addresss to query * @param ids tokens to query * @return token balances */ function _balanceOfBatch( address[] memory accounts, uint256[] memory ids ) internal view virtual returns (uint256[] memory) { if (accounts.length != ids.length) revert MultiToken__ArrayLengthMismatch(); mapping(uint256 tokenId => mapping(address account => uint256 balance)) storage balances = ERC1155Storage .ref(ERC1155Storage.DEFAULT_STORAGE_SLOT) .balances; uint256[] memory batchBalances = new uint256[](accounts.length); unchecked { for (uint256 i; i < accounts.length; i++) { if (accounts[i] == address(0)) revert MultiToken__BalanceQueryZeroAddress(); batchBalances[i] = balances[ids[i]][accounts[i]]; } } return batchBalances; } /** * @notice query approval status of given operator with respect to given address * @param account address to query for approval granted * @param operator address to query for approval received * @return whether operator is approved to spend tokens held by account */ function _isApprovedForAll( address account, address operator ) internal view virtual returns (bool) { return ERC1155Storage .ref(ERC1155Storage.DEFAULT_STORAGE_SLOT) .operatorApprovals[account][operator]; } function _setApprovalForAll( address operator, bool status ) internal virtual { if (_msgSender() == operator) revert MultiToken__SelfApproval(); ERC1155Storage .ref(ERC1155Storage.DEFAULT_STORAGE_SLOT) .operatorApprovals[_msgSender()][operator] = status; emit ApprovalForAll(_msgSender(), operator, status); } /** * @notice mint given quantity of tokens for given address * @dev ERC1155Receiver implementation is not checked * @param account beneficiary of minting * @param id token ID * @param amount quantity of tokens to mint * @param data data payload */ function _mint( address account, uint256 id, uint256 amount, bytes memory data ) internal virtual { if (account == address(0)) revert MultiToken__MintToZeroAddress(); _beforeTokenTransfer( _msgSender(), address(0), account, _asSingletonArray(id), _asSingletonArray(amount), data ); ERC1155Storage.ref(ERC1155Storage.DEFAULT_STORAGE_SLOT).balances[id][ account ] += amount; emit TransferSingle(_msgSender(), address(0), account, id, amount); } /** * @notice mint given quantity of tokens for given address * @param account beneficiary of minting * @param id token ID * @param amount quantity of tokens to mint * @param data data payload */ function _safeMint( address account, uint256 id, uint256 amount, bytes memory data ) internal virtual { _mint(account, id, amount, data); _doSafeTransferAcceptanceCheck( _msgSender(), address(0), account, id, amount, data ); } /** * @notice mint batch of tokens for given address * @dev ERC1155Receiver implementation is not checked * @param account beneficiary of minting * @param ids list of token IDs * @param amounts list of quantities of tokens to mint * @param data data payload */ function _mintBatch( address account, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual { if (account == address(0)) revert MultiToken__MintToZeroAddress(); if (ids.length != amounts.length) revert MultiToken__ArrayLengthMismatch(); _beforeTokenTransfer( _msgSender(), address(0), account, ids, amounts, data ); mapping(uint256 tokenId => mapping(address account => uint256 balance)) storage balances = ERC1155Storage .ref(ERC1155Storage.DEFAULT_STORAGE_SLOT) .balances; for (uint256 i; i < ids.length; ) { balances[ids[i]][account] += amounts[i]; unchecked { i++; } } emit TransferBatch(_msgSender(), address(0), account, ids, amounts); } /** * @notice mint batch of tokens for given address * @param account beneficiary of minting * @param ids list of token IDs * @param amounts list of quantities of tokens to mint * @param data data payload */ function _safeMintBatch( address account, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual { _mintBatch(account, ids, amounts, data); _doSafeBatchTransferAcceptanceCheck( _msgSender(), address(0), account, ids, amounts, data ); } /** * @notice burn given quantity of tokens held by given address * @param account holder of tokens to burn * @param id token ID * @param amount quantity of tokens to burn */ function _burn( address account, uint256 id, uint256 amount ) internal virtual { if (account == address(0)) revert MultiToken__BurnFromZeroAddress(); _beforeTokenTransfer( _msgSender(), account, address(0), _asSingletonArray(id), _asSingletonArray(amount), '' ); mapping(address account => uint256 balance) storage balances = ERC1155Storage .ref(ERC1155Storage.DEFAULT_STORAGE_SLOT) .balances[id]; unchecked { if (amount > balances[account]) revert MultiToken__BurnExceedsBalance(); balances[account] -= amount; } emit TransferSingle(_msgSender(), account, address(0), id, amount); } /** * @notice burn given batch of tokens held by given address * @param account holder of tokens to burn * @param ids token IDs * @param amounts quantities of tokens to burn */ function _burnBatch( address account, uint256[] memory ids, uint256[] memory amounts ) internal virtual { if (account == address(0)) revert MultiToken__BurnFromZeroAddress(); if (ids.length != amounts.length) revert MultiToken__ArrayLengthMismatch(); _beforeTokenTransfer( _msgSender(), account, address(0), ids, amounts, '' ); mapping(uint256 tokenId => mapping(address account => uint256 balance)) storage balances = ERC1155Storage .ref(ERC1155Storage.DEFAULT_STORAGE_SLOT) .balances; unchecked { for (uint256 i; i < ids.length; i++) { uint256 id = ids[i]; if (amounts[i] > balances[id][account]) revert MultiToken__BurnExceedsBalance(); balances[id][account] -= amounts[i]; } } emit TransferBatch(_msgSender(), account, address(0), ids, amounts); } function _safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes memory data ) internal virtual { if (from != _msgSender() && !_isApprovedForAll(from, _msgSender())) revert MultiToken__NotOwnerOrApproved(); _safeTransfer(_msgSender(), from, to, id, amount, data); } function _safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual { if (from != _msgSender() && !_isApprovedForAll(from, _msgSender())) revert MultiToken__NotOwnerOrApproved(); _safeTransferBatch(_msgSender(), from, to, ids, amounts, data); } /** * @notice transfer tokens between given addresses * @dev ERC1155Receiver implementation is not checked * @param operator executor of transfer * @param sender sender of tokens * @param recipient receiver of tokens * @param id token ID * @param amount quantity of tokens to transfer * @param data data payload */ function _transfer( address operator, address sender, address recipient, uint256 id, uint256 amount, bytes memory data ) internal virtual { if (recipient == address(0)) revert MultiToken__TransferToZeroAddress(); _beforeTokenTransfer( operator, sender, recipient, _asSingletonArray(id), _asSingletonArray(amount), data ); mapping(uint256 tokenId => mapping(address account => uint256 balance)) storage balances = ERC1155Storage .ref(ERC1155Storage.DEFAULT_STORAGE_SLOT) .balances; unchecked { uint256 senderBalance = balances[id][sender]; if (amount > senderBalance) revert MultiToken__TransferExceedsBalance(); balances[id][sender] = senderBalance - amount; } balances[id][recipient] += amount; emit TransferSingle(operator, sender, recipient, id, amount); } /** * @notice transfer tokens between given addresses * @param operator executor of transfer * @param sender sender of tokens * @param recipient receiver of tokens * @param id token ID * @param amount quantity of tokens to transfer * @param data data payload */ function _safeTransfer( address operator, address sender, address recipient, uint256 id, uint256 amount, bytes memory data ) internal virtual { _transfer(operator, sender, recipient, id, amount, data); _doSafeTransferAcceptanceCheck( operator, sender, recipient, id, amount, data ); } /** * @notice transfer batch of tokens between given addresses * @dev ERC1155Receiver implementation is not checked * @param operator executor of transfer * @param sender sender of tokens * @param recipient receiver of tokens * @param ids token IDs * @param amounts quantities of tokens to transfer * @param data data payload */ function _transferBatch( address operator, address sender, address recipient, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual { if (recipient == address(0)) revert MultiToken__TransferToZeroAddress(); if (ids.length != amounts.length) revert MultiToken__ArrayLengthMismatch(); _beforeTokenTransfer(operator, sender, recipient, ids, amounts, data); mapping(uint256 tokenId => mapping(address account => uint256 balance)) storage balances = ERC1155Storage .ref(ERC1155Storage.DEFAULT_STORAGE_SLOT) .balances; for (uint256 i; i < ids.length; ) { uint256 token = ids[i]; uint256 amount = amounts[i]; unchecked { uint256 senderBalance = balances[token][sender]; if (amount > senderBalance) revert MultiToken__TransferExceedsBalance(); balances[token][sender] = senderBalance - amount; i++; } // balance increase cannot be unchecked because MultiToken neither tracks nor validates a totalSupply balances[token][recipient] += amount; } emit TransferBatch(operator, sender, recipient, ids, amounts); } /** * @notice transfer batch of tokens between given addresses * @param operator executor of transfer * @param sender sender of tokens * @param recipient receiver of tokens * @param ids token IDs * @param amounts quantities of tokens to transfer * @param data data payload */ function _safeTransferBatch( address operator, address sender, address recipient, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual { _transferBatch(operator, sender, recipient, ids, amounts, data); _doSafeBatchTransferAcceptanceCheck( operator, sender, recipient, ids, amounts, data ); } /** * @notice wrap given element in array of length 1 * @param element element to wrap * @return singleton array */ function _asSingletonArray( uint256 element ) private pure returns (uint256[] memory) { uint256[] memory array = new uint256[](1); array[0] = element; return array; } /** * @notice revert if applicable transfer recipient is not valid ERC1155Receiver * @param operator executor of transfer * @param from sender of tokens * @param to receiver of tokens * @param id token ID * @param amount quantity of tokens to transfer * @param data data payload */ function _doSafeTransferAcceptanceCheck( address operator, address from, address to, uint256 id, uint256 amount, bytes memory data ) private { if (to.isContract()) { try IERC1155Receiver(to).onERC1155Received( operator, from, id, amount, data ) returns (bytes4 response) { if (response != IERC1155Receiver.onERC1155Received.selector) revert MultiToken__ERC1155ReceiverRejected(); } catch Error(string memory reason) { revert(reason); } catch { revert MultiToken__ERC1155ReceiverNotImplemented(); } } } /** * @notice revert if applicable transfer recipient is not valid ERC1155Receiver * @param operator executor of transfer * @param from sender of tokens * @param to receiver of tokens * @param ids token IDs * @param amounts quantities of tokens to transfer * @param data data payload */ function _doSafeBatchTransferAcceptanceCheck( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) private { if (to.isContract()) { try IERC1155Receiver(to).onERC1155BatchReceived( operator, from, ids, amounts, data ) returns (bytes4 response) { if ( response != IERC1155Receiver.onERC1155BatchReceived.selector ) revert MultiToken__ERC1155ReceiverRejected(); } catch Error(string memory reason) { revert(reason); } catch { revert MultiToken__ERC1155ReceiverNotImplemented(); } } } /** * @notice ERC1155 hook, called before all transfers including mint and burn * @dev function should be overridden and new implementation must call super * @dev called for both single and batch transfers * @param operator executor of transfer * @param from sender of tokens * @param to receiver of tokens * @param ids token IDs * @param amounts quantities of tokens to transfer * @param data data payload */ function _beforeTokenTransfer( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual {} }