ERC1155
Smart contract ERC1155 utilities and implementations
Outdated Version
This set of interfaces and contracts are all related to the ERC1155 Multi Token Standard.
The EIP consists of three interfaces which fulfill different roles, found here as IERC1155
, IERC1155MetadataURI
and IERC1155Receiver
.
ERC1155
implements the mandatory IERC1155
interface, as well as the optional extension IERC1155MetadataURI
, by relying on the substitution mechanism to use the same URI for all token types, dramatically reducing gas costs.
Additionally there are multiple custom extensions, including:
- designation of addresses that can pause token transfers for all users (
ERC1155Pausable
). - destruction of own tokens (
ERC1155Burnable
).
This core set of contracts is designed to be unopinionated, allowing developers to access the internal functions in ERC1155 (such as _mint
) and expose them as external functions in the way they prefer. On the other hand, ERC1155 Presets (such as ERC1155PresetMinterPauser
) are designed using opinionated patterns to provide developers with ready to use, deployable contracts.
Core
Extensions
Presets
These contracts are preconfigured combinations of the above features. They can be used through inheritance or as models to copy and paste their source code.
Utilities
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
Implementation of the basic standard multi-token. See https://eips.ethereum.org/EIPS/eip-1155 Originally based on code by Enjin: https://github.com/enjin/erc-1155
Available since v3.1.
Functions
- constructor(uri_)
- supportsInterface(interfaceId)
- uri()
- balanceOf(account, id)
- balanceOfBatch(accounts, ids)
- setApprovalForAll(operator, approved)
- isApprovedForAll(account, operator)
- safeTransferFrom(from, to, id, amount, data)
- safeBatchTransferFrom(from, to, ids, amounts, data)
- _safeTransferFrom(from, to, id, amount, data)
- _safeBatchTransferFrom(from, to, ids, amounts, data)
- _setURI(newuri)
- _mint(to, id, amount, data)
- _mintBatch(to, ids, amounts, data)
- _burn(from, id, amount)
- _burnBatch(from, ids, amounts)
- _setApprovalForAll(owner, operator, approved)
- _beforeTokenTransfer(operator, from, to, ids, amounts, data)
- _afterTokenTransfer(operator, from, to, ids, amounts, data)
IERC1155MetadataURI
IERC1155
ERC165
IERC165
Events
constructor(string uri_)
public
#See ERC1155._setURI
.
supportsInterface(bytes4 interfaceId) → bool
public
#uri(uint256) → string
public
#This implementation returns the same URI for all token types. It relies on the token type ID substitution mechanism defined in the EIP.
Clients calling this function must replace the \{id\}
substring with the
actual token type ID.
balanceOf(address account, uint256 id) → uint256
public
#balanceOfBatch(address[] accounts, uint256[] ids) → uint256[]
public
#setApprovalForAll(address operator, bool approved)
public
#isApprovedForAll(address account, address operator) → bool
public
#safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes data)
public
#safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] amounts, bytes data)
public
#_safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes data)
internal
#Transfers amount
tokens of token type id
from from
to to
.
Emits a IERC1155.TransferSingle
event.
Requirements:
to
cannot be the zero address.from
must have a balance of tokens of typeid
of at leastamount
.- If
to
refers to a smart contract, it must implementIERC1155Receiver.onERC1155Received
and return the acceptance magic value.
_safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] amounts, bytes data)
internal
#xref:ROOT:erc1155#batch-operations[Batched] version of ERC1155._safeTransferFrom
.
Emits a IERC1155.TransferBatch
event.
Requirements:
- If
to
refers to a smart contract, it must implementIERC1155Receiver.onERC1155BatchReceived
and return the acceptance magic value.
_setURI(string newuri)
internal
#Sets a new URI for all token types, by relying on the token type ID substitution mechanism defined in the EIP.
By this mechanism, any occurrence of the \{id\}
substring in either the
URI or any of the amounts in the JSON file at said URI will be replaced by
clients with the token type ID.
For example, the https://token-cdn-domain/\{id\}.json
URI would be
interpreted by clients as
https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json
for token type ID 0x4cce0.
See ERC1155.uri
.
Because these URIs cannot be meaningfully represented by the IERC1155.URI
event,
this function emits no events.
_mint(address to, uint256 id, uint256 amount, bytes data)
internal
#Creates amount
tokens of token type id
, and assigns them to to
.
Emits a IERC1155.TransferSingle
event.
Requirements:
to
cannot be the zero address.- If
to
refers to a smart contract, it must implementIERC1155Receiver.onERC1155Received
and return the acceptance magic value.
_mintBatch(address to, uint256[] ids, uint256[] amounts, bytes data)
internal
#xref:ROOT:erc1155#batch-operations[Batched] version of ERC1155._mint
.
Emits a IERC1155.TransferBatch
event.
Requirements:
ids
andamounts
must have the same length.- If
to
refers to a smart contract, it must implementIERC1155Receiver.onERC1155BatchReceived
and return the acceptance magic value.
_burn(address from, uint256 id, uint256 amount)
internal
#Destroys amount
tokens of token type id
from from
Emits a IERC1155.TransferSingle
event.
Requirements:
from
cannot be the zero address.from
must have at leastamount
tokens of token typeid
.
_burnBatch(address from, uint256[] ids, uint256[] amounts)
internal
#xref:ROOT:erc1155#batch-operations[Batched] version of ERC1155._burn
.
Emits a IERC1155.TransferBatch
event.
Requirements:
ids
andamounts
must have the same length.
_setApprovalForAll(address owner, address operator, bool approved)
internal
#Approve operator
to operate on all of owner
tokens
Emits an IERC1155.ApprovalForAll
event.
_beforeTokenTransfer(address operator, address from, address to, uint256[] ids, uint256[] amounts, bytes data)
internal
#Hook that is called before any token transfer. This includes minting and burning, as well as batched variants.
The same hook is called on both single and batched variants. For single
transfers, the length of the ids
and amounts
arrays will be 1.
Calling conditions (for each id
and amount
pair):
- When
from
andto
are both non-zero,amount
offrom
's tokens of token typeid
will be transferred toto
. - When
from
is zero,amount
tokens of token typeid
will be minted forto
. - when
to
is zero,amount
offrom
's tokens of token typeid
will be burned. from
andto
are never both zero.ids
andamounts
have the same, non-zero length.
To learn more about hooks, head to xref:ROOT:extending-contracts#using-hooks[Using Hooks].
_afterTokenTransfer(address operator, address from, address to, uint256[] ids, uint256[] amounts, bytes data)
internal
#Hook that is called after any token transfer. This includes minting and burning, as well as batched variants.
The same hook is called on both single and batched variants. For single
transfers, the length of the id
and amount
arrays will be 1.
Calling conditions (for each id
and amount
pair):
- When
from
andto
are both non-zero,amount
offrom
's tokens of token typeid
will be transferred toto
. - When
from
is zero,amount
tokens of token typeid
will be minted forto
. - when
to
is zero,amount
offrom
's tokens of token typeid
will be burned. from
andto
are never both zero.ids
andamounts
have the same, non-zero length.
To learn more about hooks, head to xref:ROOT:extending-contracts#using-hooks[Using Hooks].
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
Required interface of an ERC1155 compliant contract, as defined in the EIP.
Available since v3.1.
Functions
Events
balanceOf(address account, uint256 id) → uint256
external
#Returns the amount of tokens of token type id
owned by account
.
Requirements:
account
cannot be the zero address.
balanceOfBatch(address[] accounts, uint256[] ids) → uint256[]
external
#xref:ROOT:erc1155#batch-operations[Batched] version of ERC1155.balanceOf
.
Requirements:
accounts
andids
must have the same length.
setApprovalForAll(address operator, bool approved)
external
#Grants or revokes permission to operator
to transfer the caller's tokens, according to approved
,
Emits an IERC1155.ApprovalForAll
event.
Requirements:
operator
cannot be the caller.
isApprovedForAll(address account, address operator) → bool
external
#Returns true if operator
is approved to transfer account
's tokens.
safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes data)
external
#Transfers amount
tokens of token type id
from from
to to
.
Emits a IERC1155.TransferSingle
event.
Requirements:
to
cannot be the zero address.- If the caller is not
from
, it must have been approved to spendfrom
's tokens viaERC1155.setApprovalForAll
. from
must have a balance of tokens of typeid
of at leastamount
.- If
to
refers to a smart contract, it must implementIERC1155Receiver.onERC1155Received
and return the acceptance magic value.
safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] amounts, bytes data)
external
#xref:ROOT:erc1155#batch-operations[Batched] version of ERC1155.safeTransferFrom
.
Emits a IERC1155.TransferBatch
event.
Requirements:
ids
andamounts
must have the same length.- If
to
refers to a smart contract, it must implementIERC1155Receiver.onERC1155BatchReceived
and return the acceptance magic value.
TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value)
event
#Emitted when value
tokens of token type id
are transferred from from
to to
by operator
.
TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values)
event
#Equivalent to multiple IERC1155.TransferSingle
events, where operator
, from
and to
are the same for all
transfers.
ApprovalForAll(address indexed account, address indexed operator, bool approved)
event
#Emitted when account
grants or revokes permission to operator
to transfer their tokens, according to
approved
.
URI(string value, uint256 indexed id)
event
#Emitted when the URI for token type id
changes to value
, if it is a non-programmatic URI.
If an IERC1155.URI
event was emitted for id
, the standard
guarantees that value
will equal the value
returned by IERC1155MetadataURI.uri
.
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
Available since v3.1.
Functions
onERC1155Received(address operator, address from, uint256 id, uint256 value, bytes data) → bytes4
external
#Handles the receipt of a single ERC1155 token type. This function is
called at the end of a safeTransferFrom
after the balance has been updated.
NOTE: To accept the transfer, this must return
bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))
(i.e. 0xf23a6e61, or its own function selector).
onERC1155BatchReceived(address operator, address from, uint256[] ids, uint256[] values, bytes data) → bytes4
external
#Handles the receipt of a multiple ERC1155 token types. This function
is called at the end of a safeBatchTransferFrom
after the balances have
been updated.
NOTE: To accept the transfer(s), this must return
bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))
(i.e. 0xbc197c81, or its own function selector).
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
Extension of ERC1155
that allows token holders to destroy both their
own tokens and those that they have been approved to use.
Available since v3.1.
Functions
ERC1155
- supportsInterface(interfaceId)
- uri()
- balanceOf(account, id)
- balanceOfBatch(accounts, ids)
- setApprovalForAll(operator, approved)
- isApprovedForAll(account, operator)
- safeTransferFrom(from, to, id, amount, data)
- safeBatchTransferFrom(from, to, ids, amounts, data)
- _safeTransferFrom(from, to, id, amount, data)
- _safeBatchTransferFrom(from, to, ids, amounts, data)
- _setURI(newuri)
- _mint(to, id, amount, data)
- _mintBatch(to, ids, amounts, data)
- _burn(from, id, amount)
- _burnBatch(from, ids, amounts)
- _setApprovalForAll(owner, operator, approved)
- _beforeTokenTransfer(operator, from, to, ids, amounts, data)
- _afterTokenTransfer(operator, from, to, ids, amounts, data)
IERC1155MetadataURI
IERC1155
ERC165
IERC165
Events
burn(address account, uint256 id, uint256 value)
public
#burnBatch(address account, uint256[] ids, uint256[] values)
public
#import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Pausable.sol";
ERC1155 token with pausable token transfers, minting and burning.
Useful for scenarios such as preventing trades until the end of an evaluation period, or having an emergency switch for freezing all token transfers in the event of a large bug.
This contract does not include public pause and unpause functions. In
addition to inheriting this contract, you must define both functions, invoking the
Pausable._pause
and Pausable._unpause
internal functions, with appropriate
access control, e.g. using AccessControl
or Ownable
. Not doing so will
make the contract unpausable.
Available since v3.1.
Functions
Pausable
ERC1155
- supportsInterface(interfaceId)
- uri()
- balanceOf(account, id)
- balanceOfBatch(accounts, ids)
- setApprovalForAll(operator, approved)
- isApprovedForAll(account, operator)
- safeTransferFrom(from, to, id, amount, data)
- safeBatchTransferFrom(from, to, ids, amounts, data)
- _safeTransferFrom(from, to, id, amount, data)
- _safeBatchTransferFrom(from, to, ids, amounts, data)
- _setURI(newuri)
- _mint(to, id, amount, data)
- _mintBatch(to, ids, amounts, data)
- _burn(from, id, amount)
- _burnBatch(from, ids, amounts)
- _setApprovalForAll(owner, operator, approved)
- _afterTokenTransfer(operator, from, to, ids, amounts, data)
IERC1155MetadataURI
IERC1155
ERC165
IERC165
Events
_beforeTokenTransfer(address operator, address from, address to, uint256[] ids, uint256[] amounts, bytes data)
internal
#import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
Extension of ERC1155 that adds tracking of total supply per id.
Useful for scenarios where Fungible and Non-fungible tokens have to be clearly identified. Note: While a totalSupply of 1 might mean the corresponding is an NFT, there is no guarantees that no other token with the same id are not going to be minted.
Functions
ERC1155
- supportsInterface(interfaceId)
- uri()
- balanceOf(account, id)
- balanceOfBatch(accounts, ids)
- setApprovalForAll(operator, approved)
- isApprovedForAll(account, operator)
- safeTransferFrom(from, to, id, amount, data)
- safeBatchTransferFrom(from, to, ids, amounts, data)
- _safeTransferFrom(from, to, id, amount, data)
- _safeBatchTransferFrom(from, to, ids, amounts, data)
- _setURI(newuri)
- _mint(to, id, amount, data)
- _mintBatch(to, ids, amounts, data)
- _burn(from, id, amount)
- _burnBatch(from, ids, amounts)
- _setApprovalForAll(owner, operator, approved)
- _afterTokenTransfer(operator, from, to, ids, amounts, data)
IERC1155MetadataURI
IERC1155
ERC165
IERC165
Events
totalSupply(uint256 id) → uint256
public
#Total amount of tokens in with a given id.
exists(uint256 id) → bool
public
#Indicates whether any token exist with a given id, or not.
_beforeTokenTransfer(address operator, address from, address to, uint256[] ids, uint256[] amounts, bytes data)
internal
#import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155URIStorage.sol";
ERC1155 token with storage based token URI management. Inspired by the ERC721URIStorage extension
Available since v4.6.
Functions
ERC1155
- supportsInterface(interfaceId)
- balanceOf(account, id)
- balanceOfBatch(accounts, ids)
- setApprovalForAll(operator, approved)
- isApprovedForAll(account, operator)
- safeTransferFrom(from, to, id, amount, data)
- safeBatchTransferFrom(from, to, ids, amounts, data)
- _safeTransferFrom(from, to, id, amount, data)
- _safeBatchTransferFrom(from, to, ids, amounts, data)
- _setURI(newuri)
- _mint(to, id, amount, data)
- _mintBatch(to, ids, amounts, data)
- _burn(from, id, amount)
- _burnBatch(from, ids, amounts)
- _setApprovalForAll(owner, operator, approved)
- _beforeTokenTransfer(operator, from, to, ids, amounts, data)
- _afterTokenTransfer(operator, from, to, ids, amounts, data)
IERC1155MetadataURI
IERC1155
ERC165
IERC165
Events
uri(uint256 tokenId) → string
public
#This implementation returns the concatenation of the _baseURI
and the token-specific uri if the latter is set
This enables the following behaviors:
-
if
_tokenURIs[tokenId]
is set, then the result is the concatenation of_baseURI
and_tokenURIs[tokenId]
(keep in mind that_baseURI
is empty per default); -
if
_tokenURIs[tokenId]
is NOT set then we fallback tosuper.uri()
which in most cases will containERC1155._uri
; -
if
_tokenURIs[tokenId]
is NOT set, and if the parents do not have a uri value set, then the result is empty.
_setURI(uint256 tokenId, string tokenURI)
internal
#Sets tokenURI
as the tokenURI of tokenId
.
_setBaseURI(string baseURI)
internal
#Sets baseURI
as the _baseURI
for all tokens
import "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol";
Interface of the optional ERC1155MetadataExtension interface, as defined in the EIP.
Available since v3.1.
Functions
Events
uri(uint256 id) → string
external
#Returns the URI for token type id
.
If the \{id\}
substring is present in the URI, it must be replaced by
clients with the actual token type ID.
import "@openzeppelin/contracts/token/ERC1155/presets/ERC1155PresetMinterPauser.sol";
ERC1155
token, including:
- ability for holders to burn (destroy) their tokens
- a minter role that allows for token minting (creation)
- a pauser role that allows to stop all token transfers
This contract uses AccessControl
to lock permissioned functions using the
different roles - head to its documentation for details.
The account that deploys the contract will be granted the minter and pauser roles, as well as the default admin role, which will let it grant both minter and pauser roles to other accounts.
Deprecated in favor of Contracts Wizard.
Functions
- constructor(uri)
- mint(to, id, amount, data)
- mintBatch(to, ids, amounts, data)
- pause()
- unpause()
- supportsInterface(interfaceId)
- _beforeTokenTransfer(operator, from, to, ids, amounts, data)
- MINTER_ROLE()
- PAUSER_ROLE()
ERC1155Pausable
Pausable
ERC1155Burnable
ERC1155
- uri()
- balanceOf(account, id)
- balanceOfBatch(accounts, ids)
- setApprovalForAll(operator, approved)
- isApprovedForAll(account, operator)
- safeTransferFrom(from, to, id, amount, data)
- safeBatchTransferFrom(from, to, ids, amounts, data)
- _safeTransferFrom(from, to, id, amount, data)
- _safeBatchTransferFrom(from, to, ids, amounts, data)
- _setURI(newuri)
- _mint(to, id, amount, data)
- _mintBatch(to, ids, amounts, data)
- _burn(from, id, amount)
- _burnBatch(from, ids, amounts)
- _setApprovalForAll(owner, operator, approved)
- _afterTokenTransfer(operator, from, to, ids, amounts, data)
IERC1155MetadataURI
IERC1155
AccessControlEnumerable
- getRoleMember(role, index)
- getRoleMemberCount(role)
- _grantRole(role, account)
- _revokeRole(role, account)
AccessControl
- hasRole(role, account)
- _checkRole(role)
- _checkRole(role, account)
- getRoleAdmin(role)
- grantRole(role, account)
- revokeRole(role, account)
- renounceRole(role, account)
- _setupRole(role, account)
- _setRoleAdmin(role, adminRole)
- DEFAULT_ADMIN_ROLE()
ERC165
IERC165
IAccessControlEnumerable
IAccessControl
Events
ERC1155Pausable
Pausable
ERC1155Burnable
ERC1155
IERC1155MetadataURI
IERC1155
- TransferSingle(operator, from, to, id, value)
- TransferBatch(operator, from, to, ids, values)
- ApprovalForAll(account, operator, approved)
- URI(value, id)
AccessControlEnumerable
AccessControl
ERC165
IERC165
IAccessControlEnumerable
IAccessControl
constructor(string uri)
public
#Grants DEFAULT_ADMIN_ROLE
, MINTER_ROLE
, and PAUSER_ROLE
to the account that
deploys the contract.
mint(address to, uint256 id, uint256 amount, bytes data)
public
#Creates amount
new tokens for to
, of token type id
.
See ERC1155._mint
.
Requirements:
- the caller must have the
MINTER_ROLE
.
mintBatch(address to, uint256[] ids, uint256[] amounts, bytes data)
public
#xref:ROOT:erc1155#batch-operations[Batched] variant of IERC4626.mint
.
pause()
public
#Pauses all token transfers.
See ERC1155Pausable
and Pausable._pause
.
Requirements:
- the caller must have the
PAUSER_ROLE
.
unpause()
public
#Unpauses all token transfers.
See ERC1155Pausable
and Pausable._unpause
.
Requirements:
- the caller must have the
PAUSER_ROLE
.
supportsInterface(bytes4 interfaceId) → bool
public
#_beforeTokenTransfer(address operator, address from, address to, uint256[] ids, uint256[] amounts, bytes data)
internal
#MINTER_ROLE() → bytes32
public
#PAUSER_ROLE() → bytes32
public
#import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
Available since v3.1.
Functions
onERC1155Received(address, address, uint256, uint256, bytes) → bytes4
public
#onERC1155BatchReceived(address, address, uint256[], uint256[], bytes) → bytes4
public
#import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Receiver.sol";
Available since v3.1.
Functions
supportsInterface(bytes4 interfaceId) → bool
public
#