Contract Name:
ERC721GenerativeGenesis
Contract Source Code:
//SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
import { Base64 } from "@openzeppelin/contracts/utils/Base64.sol";
import "./ERC721Base.sol";
import "../tokenManager/interfaces/IPostTransfer.sol";
import "../tokenManager/interfaces/IPostBurn.sol";
import "./interfaces/IERC721GeneralMint.sol";
import "./ERC721GeneralGenesisBase.sol";
/**
* @title Generative ERC721
* @author highlight.xyz
* @notice Generative NFT smart contract
*/
contract ERC721GenerativeGenesis is ERC721GeneralGenesisBase {
using EnumerableSet for EnumerableSet.AddressSet;
/**
* @notice Generative Code URI
*/
string private _generativeCodeURI;
/**
* @notice Initialize the contract
* @param data Data to initialize the contract
* @ param creator Creator/owner of contract
* @ param _contractURI Contract metadata
* @ param defaultRoyalty Default royalty object for contract (optional)
* @ param _defaultTokenManager Default token manager for contract (optional)
* @ param _name Name of token edition
* @ param _symbol Symbol of the token edition
* @ param trustedForwarder Trusted minimal forwarder
* @ param initialMinter Initial minter to register
* @ param _generativeCodeURI Generative code URI
* @ param newBaseURI Base URI for contract
* @ param _limitSupply Initial limit supply
* @ param useMarketplaceFiltererRegistry Denotes whether to use marketplace filterer registry
* @param _observability Observability contract address
*/
function initialize(bytes calldata data, address _observability) external initializer {
(
address creator,
string memory _contractURI,
IRoyaltyManager.Royalty memory defaultRoyalty,
address _defaultTokenManager,
string memory _name,
string memory _symbol,
address trustedForwarder,
address initialMinter,
string memory _codeURI,
string memory newBaseURI,
uint256 _limitSupply,
bool useMarketplaceFiltererRegistry
) = abi.decode(
data,
(
address,
string,
IRoyaltyManager.Royalty,
address,
string,
string,
address,
address,
string,
string,
uint256,
bool
)
);
__ERC721URIStorage_init();
__ERC721Base_initialize(creator, defaultRoyalty, _defaultTokenManager);
__ERC2771ContextUpgradeable__init__(trustedForwarder);
__ERC721A_init(_name, _symbol);
_minters.add(initialMinter);
contractURI = _contractURI;
_generativeCodeURI = _codeURI;
IObservability(_observability).emitGenerativeSeriesDeployed(address(this));
observability = IObservability(_observability);
if (bytes(newBaseURI).length > 0) {
_setBaseURI(newBaseURI);
// don't emit on observability contract here
}
if (_limitSupply > 0) {
limitSupply = _limitSupply;
// don't emit on observability contract here
}
}
/**
* @notice Generative Code URI
**/
function generativeCodeUri() external view returns (string memory) {
return _generativeCodeURI;
}
function tokenImage(string memory _owner) external pure returns (string memory) {
bytes memory owner = bytes(_owner);
require(owner.length == 42, "Wrong wallet address");
string
memory svg = '<svg xmlns="http://www.w3.org/2000/svg" id="0xeE9be9846abB49532a03C05FC27A0e4Dbc84e857" viewBox="0 0 700 700"><style>.a{stroke-width:20;}</style><g class="a" fill="none">';
uint256 r = 270;
for (uint256 i = 0; i < 39; ) {
string memory hexCode;
if (i == 0) {
hexCode = string(abi.encodePacked("#00", owner[i + 2]));
} else {
hexCode = string(abi.encodePacked("#", owner[i], owner[i + 1], owner[i + 2]));
}
svg = string(
abi.encodePacked(
svg,
'<circle cx="350" cy="350" r="',
Strings.toString(r),
'" stroke="',
hexCode,
'"/>'
)
);
r -= 20;
i += 3;
}
return
encodeSVG(
abi.encodePacked(
svg,
'<circle cx="350" cy="350" r="10" stroke="#',
owner[39],
owner[40],
owner[41],
'"/>',
"</g></svg>"
)
);
}
/**
* @notice Generate token image based on owner wallet address.
* @param chainId Chain ID contract is deployed to
* @param tokenId Token ID to get animation for
* @param walletAddress Wallet address that owns the token
* @param contractAddress Contract Address
* @param hash Transaction Hash the token was minted in.
* @param blockHash Block Hash the token was minted in.
* @param blockNumber Block Number the token was minted in.
* @param timestamp Timestamp of the block
* @param gasPrice Gas price of the transaction in gwei.
**/
function tokenAnimation(
uint256 chainId,
uint256 tokenId,
string memory walletAddress,
string memory contractAddress,
string memory hash,
string memory blockHash,
uint256 blockNumber,
uint256 timestamp,
uint256 gasPrice
) external view returns (string memory) {
return
string(
abi.encodePacked(
_generativeCodeURI,
"/index.html?",
_constructHashParams(contractAddress, walletAddress, hash, blockHash),
_constructIds(tokenId, chainId, blockNumber, timestamp, gasPrice)
)
);
}
/**
* @notice Construct Hash params.
* @param walletAddress Wallet address that owns the token
* @param contractAddress Contract Address
* @param hash Transaction Hash the token was minted in.
* @param blockHash Block Hash the token was minted in.
**/
function _constructHashParams(
string memory contractAddress,
string memory walletAddress,
string memory hash,
string memory blockHash
) private pure returns (string memory) {
return string(abi.encodePacked("a=", contractAddress, "&h=", hash, "&bh=", blockHash, "&wa=", walletAddress));
}
/**
* @notice Construct ID params.
* @param chainId Chain ID contract is deployed to
* @param tokenId Token ID to get animation for
* @param blockNumber Block Number the token was minted in.
* @param timestamp Timestamp of the block
* @param gasPrice Gas price of the transaction in gwei.
**/
function _constructIds(
uint256 tokenId,
uint256 chainId,
uint256 blockNumber,
uint256 timestamp,
uint256 gasPrice
) private pure returns (string memory) {
return
string(
abi.encodePacked(
"&c=",
Strings.toString(chainId),
"&tid=",
Strings.toString(tokenId),
"&bn=",
Strings.toString(blockNumber),
"&t=",
Strings.toString(timestamp),
"&gp=",
Strings.toString(gasPrice)
)
);
}
/**
* @param svg Raw svg to base64 and turn into a data-uri
* @dev Encodes the argument svg bytes into base64-data uri format
*/
function encodeSVG(bytes memory svg) private pure returns (string memory) {
return string(abi.encodePacked("data:image/svg+xml;base64,", Base64.encode(svg)));
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides a set of functions to operate with Base64 strings.
*
* _Available since v4.5._
*/
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
/**
* Inspired by Brecht Devos (Brechtpd) implementation - MIT licence
* https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol
*/
if (data.length == 0) return "";
// Loads the table into memory
string memory table = _TABLE;
// Encoding takes 3 bytes chunks of binary data from `bytes` data parameter
// and split into 4 numbers of 6 bits.
// The final Base64 length should be `bytes` data length multiplied by 4/3 rounded up
// - `data.length + 2` -> Round up
// - `/ 3` -> Number of 3-bytes chunks
// - `4 *` -> 4 characters for each chunk
string memory result = new string(4 * ((data.length + 2) / 3));
/// @solidity memory-safe-assembly
assembly {
// Prepare the lookup table (skip the first "length" byte)
let tablePtr := add(table, 1)
// Prepare result pointer, jump over length
let resultPtr := add(result, 32)
// Run over the input, 3 bytes at a time
for {
let dataPtr := data
let endPtr := add(data, mload(data))
} lt(dataPtr, endPtr) {
} {
// Advance 3 bytes
dataPtr := add(dataPtr, 3)
let input := mload(dataPtr)
// To write each character, shift the 3 bytes (18 bits) chunk
// 4 times in blocks of 6 bits for each character (18, 12, 6, 0)
// and apply logical AND with 0x3F which is the number of
// the previous character in the ASCII table prior to the Base64 Table
// The result is then added to the table to get the character to write,
// and finally write it in the result pointer but with a left shift
// of 256 (1 byte) - 8 (1 ASCII char) = 248 bits
mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
resultPtr := add(resultPtr, 1) // Advance
mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
resultPtr := add(resultPtr, 1) // Advance
mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))
resultPtr := add(resultPtr, 1) // Advance
mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))
resultPtr := add(resultPtr, 1) // Advance
}
// When data `bytes` is not exactly 3 bytes long
// it is padded with `=` characters at the end
switch mod(mload(data), 3)
case 1 {
mstore8(sub(resultPtr, 1), 0x3d)
mstore8(sub(resultPtr, 2), 0x3d)
}
case 2 {
mstore8(sub(resultPtr, 1), 0x3d)
}
}
return result;
}
}
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
import "../royaltyManager/interfaces/IRoyaltyManager.sol";
import "../tokenManager/interfaces/ITokenManager.sol";
import "../utils/Ownable.sol";
import "../utils/ERC2981/IERC2981Upgradeable.sol";
import "../utils/ERC165/ERC165CheckerUpgradeable.sol";
import "../metatx/ERC2771ContextUpgradeable.sol";
import "../observability/IObservability.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
/**
* @title Base ERC721
* @author highlight.xyz
* @notice Core piece of Highlight NFT contracts (v2)
*/
abstract contract ERC721Base is
OwnableUpgradeable,
IERC2981Upgradeable,
ERC2771ContextUpgradeable,
ReentrancyGuardUpgradeable
{
using EnumerableSet for EnumerableSet.AddressSet;
using ERC165CheckerUpgradeable for address;
/**
* @notice Throw when token or royalty manager is invalid
*/
error InvalidManager();
/**
* @notice Throw when token or royalty manager does not exist
*/
error ManagerDoesNotExist();
/**
* @notice Throw when sender is unauthorized to perform action
*/
error Unauthorized();
/**
* @notice Throw when sender is not a minter
*/
error NotMinter();
/**
* @notice Throw when token manager or royalty manager swap is blocked
*/
error ManagerSwapBlocked();
/**
* @notice Throw when token manager or royalty manager remove is blocked
*/
error ManagerRemoveBlocked();
/**
* @notice Throw when setting default or granular royalty is blocked
*/
error RoyaltySetBlocked();
/**
* @notice Throw when royalty BPS is invalid
*/
error RoyaltyBPSInvalid();
/**
* @notice Throw when minter registration is invalid
*/
error MinterRegistrationInvalid();
/**
* @notice Set of minters allowed to mint on contract
*/
EnumerableSet.AddressSet internal _minters;
/**
* @notice Global token/edition manager default
*/
address public defaultManager;
/**
* @notice Token/edition managers per token grouping.
* Edition ID if implemented by Editions contract, and token ID if implemented by General contract.
*/
mapping(uint256 => address) internal _managers;
/**
* @notice Default royalty for entire contract
*/
IRoyaltyManager.Royalty internal _defaultRoyalty;
/**
* @notice Royalty per token grouping.
* Edition ID if implemented by Editions contract, and token ID if implemented by General contract.
*/
mapping(uint256 => IRoyaltyManager.Royalty) internal _royalties;
/**
* @notice Royalty manager - optional contract that defines the conditions around setting royalties
*/
address public royaltyManager;
/**
* @notice Freezes minting on smart contract forever
*/
uint8 internal _mintFrozen;
/**
* @notice Observability contract
*/
IObservability public observability;
/**
* @notice Emitted when minter is registered or unregistered
* @param minter Minter that was changed
* @param registered True if the minter was registered, false if unregistered
*/
event MinterRegistrationChanged(address indexed minter, bool indexed registered);
/**
* @notice Emitted when token managers are set for token/edition ids
* @param _ids Edition / token ids
* @param _tokenManagers Token managers to set for tokens / editions
*/
event GranularTokenManagersSet(uint256[] _ids, address[] _tokenManagers);
/**
* @notice Emitted when token managers are removed for token/edition ids
* @param _ids Edition / token ids to remove token managers for
*/
event GranularTokenManagersRemoved(uint256[] _ids);
/**
* @notice Emitted when default token manager changed
* @param newDefaultTokenManager New default token manager. Zero address if old one was removed
*/
event DefaultTokenManagerChanged(address indexed newDefaultTokenManager);
/**
* @notice Emitted when default royalty is set
* @param recipientAddress Royalty recipient
* @param royaltyPercentageBPS Percentage of sale (in basis points) owed to royalty recipient
*/
event DefaultRoyaltySet(address indexed recipientAddress, uint16 indexed royaltyPercentageBPS);
/**
* @notice Emitted when royalties are set for edition / token ids
* @param ids Token / edition ids
* @param _newRoyalties New royalties for each token / edition
*/
event GranularRoyaltiesSet(uint256[] ids, IRoyaltyManager.Royalty[] _newRoyalties);
/**
* @notice Emitted when royalty manager is updated
* @param newRoyaltyManager New royalty manager. Zero address if old one was removed
*/
event RoyaltyManagerChanged(address indexed newRoyaltyManager);
/**
* @notice Emitted when mints are frozen permanently
*/
event MintsFrozen();
/**
* @notice Restricts calls to minters
*/
modifier onlyMinter() {
if (!_minters.contains(_msgSender())) {
_revert(NotMinter.selector);
}
_;
}
/**
* @notice Restricts calls if input royalty bps is over 10000
*/
modifier royaltyValid(uint16 _royaltyBPS) {
if (!_royaltyBPSValid(_royaltyBPS)) {
_revert(RoyaltyBPSInvalid.selector);
}
_;
}
/**
* @notice Registers a minter
* @param minter New minter
*/
function registerMinter(address minter) external onlyOwner {
if (!_minters.add(minter)) {
_revert(MinterRegistrationInvalid.selector);
}
emit MinterRegistrationChanged(minter, true);
observability.emitMinterRegistrationChanged(minter, true);
}
/**
* @notice Unregisters a minter
* @param minter Minter to unregister
*/
function unregisterMinter(address minter) external onlyOwner {
if (!_minters.remove(minter)) {
_revert(MinterRegistrationInvalid.selector);
}
emit MinterRegistrationChanged(minter, false);
observability.emitMinterRegistrationChanged(minter, false);
}
/**
* @notice Sets granular token managers if current token manager(s) allow it
* @param _ids Edition / token ids
* @param _tokenManagers Token managers to set for tokens / editions
*/
function setGranularTokenManagers(uint256[] calldata _ids, address[] calldata _tokenManagers)
external
nonReentrant
{
address msgSender = _msgSender();
address tempOwner = owner();
uint256 idsLength = _ids.length;
for (uint256 i = 0; i < idsLength; i++) {
if (!_isValidTokenManager(_tokenManagers[i])) {
_revert(InvalidManager.selector);
}
address currentTokenManager = tokenManager(_ids[i]);
if (currentTokenManager == address(0)) {
if (msgSender != tempOwner) {
_revert(Unauthorized.selector);
}
} else {
if (!ITokenManager(currentTokenManager).canSwap(msgSender, _ids[i], _managers[i])) {
_revert(ManagerSwapBlocked.selector);
}
}
_managers[_ids[i]] = _tokenManagers[i];
}
emit GranularTokenManagersSet(_ids, _tokenManagers);
observability.emitGranularTokenManagersSet(_ids, _tokenManagers);
}
/**
* @notice Remove granular token managers
* @param _ids Edition / token ids to remove token managers for
*/
function removeGranularTokenManagers(uint256[] calldata _ids) external nonReentrant {
address msgSender = _msgSender();
uint256 idsLength = _ids.length;
for (uint256 i = 0; i < idsLength; i++) {
address currentTokenManager = _managers[_ids[i]];
if (currentTokenManager == address(0)) {
_revert(ManagerDoesNotExist.selector);
}
if (!ITokenManager(currentTokenManager).canRemoveItself(msgSender, _ids[i])) {
_revert(ManagerRemoveBlocked.selector);
}
_managers[_ids[i]] = address(0);
}
emit GranularTokenManagersRemoved(_ids);
observability.emitGranularTokenManagersRemoved(_ids);
}
/**
* @notice Set default token manager if current token manager allows it
* @param _defaultTokenManager New default token manager
*/
function setDefaultTokenManager(address _defaultTokenManager) external nonReentrant {
if (!_isValidTokenManager(_defaultTokenManager)) {
_revert(InvalidManager.selector);
}
address msgSender = _msgSender();
address currentTokenManager = defaultManager;
if (currentTokenManager == address(0)) {
if (msgSender != owner()) {
_revert(Unauthorized.selector);
}
} else {
if (!ITokenManager(currentTokenManager).canSwap(msgSender, 0, _defaultTokenManager)) {
_revert(ManagerSwapBlocked.selector);
}
}
defaultManager = _defaultTokenManager;
emit DefaultTokenManagerChanged(_defaultTokenManager);
observability.emitDefaultTokenManagerChanged(_defaultTokenManager);
}
/**
* @notice Removes default token manager if current token manager allows it
*/
function removeDefaultTokenManager() external nonReentrant {
address msgSender = _msgSender();
address currentTokenManager = defaultManager;
if (currentTokenManager == address(0)) {
_revert(ManagerDoesNotExist.selector);
}
if (!ITokenManager(currentTokenManager).canRemoveItself(msgSender, 0)) {
_revert(ManagerRemoveBlocked.selector);
}
defaultManager = address(0);
emit DefaultTokenManagerChanged(address(0));
observability.emitDefaultTokenManagerChanged(address(0));
}
/**
* @notice Sets default royalty if royalty manager allows it
* @param _royalty New default royalty
*/
function setDefaultRoyalty(IRoyaltyManager.Royalty calldata _royalty)
external
nonReentrant
royaltyValid(_royalty.royaltyPercentageBPS)
{
address msgSender = _msgSender();
address _royaltyManager = royaltyManager;
if (_royaltyManager == address(0)) {
if (msgSender != owner()) {
_revert(Unauthorized.selector);
}
} else {
if (!IRoyaltyManager(_royaltyManager).canSetDefaultRoyalty(_royalty, msgSender)) {
_revert(RoyaltySetBlocked.selector);
}
}
_defaultRoyalty = _royalty;
emit DefaultRoyaltySet(_royalty.recipientAddress, _royalty.royaltyPercentageBPS);
observability.emitDefaultRoyaltySet(_royalty.recipientAddress, _royalty.royaltyPercentageBPS);
}
/**
* @notice Sets granular royalties (per token-grouping) if royalty manager allows it
* @param ids Token / edition ids
* @param _newRoyalties New royalties for each token / edition
*/
function setGranularRoyalties(uint256[] calldata ids, IRoyaltyManager.Royalty[] calldata _newRoyalties)
external
nonReentrant
{
address msgSender = _msgSender();
address tempOwner = owner();
address _royaltyManager = royaltyManager;
uint256 idsLength = ids.length;
if (_royaltyManager == address(0)) {
if (msgSender != tempOwner) {
_revert(Unauthorized.selector);
}
for (uint256 i = 0; i < idsLength; i++) {
if (!_royaltyBPSValid(_newRoyalties[i].royaltyPercentageBPS)) {
_revert(RoyaltyBPSInvalid.selector);
}
_royalties[ids[i]] = _newRoyalties[i];
}
} else {
for (uint256 i = 0; i < idsLength; i++) {
if (!_royaltyBPSValid(_newRoyalties[i].royaltyPercentageBPS)) {
_revert(RoyaltyBPSInvalid.selector);
}
if (!IRoyaltyManager(_royaltyManager).canSetGranularRoyalty(ids[i], _newRoyalties[i], msgSender)) {
_revert(RoyaltySetBlocked.selector);
}
_royalties[ids[i]] = _newRoyalties[i];
}
}
emit GranularRoyaltiesSet(ids, _newRoyalties);
observability.emitGranularRoyaltiesSet(ids, _newRoyalties);
}
/**
* @notice Sets royalty manager if current one allows it
* @param _royaltyManager New royalty manager
*/
function setRoyaltyManager(address _royaltyManager) external nonReentrant {
if (!_isValidRoyaltyManager(_royaltyManager)) {
_revert(InvalidManager.selector);
}
address msgSender = _msgSender();
address currentRoyaltyManager = royaltyManager;
if (currentRoyaltyManager == address(0)) {
if (msgSender != owner()) {
_revert(Unauthorized.selector);
}
} else {
if (!IRoyaltyManager(currentRoyaltyManager).canSwap(_royaltyManager, msgSender)) {
_revert(ManagerSwapBlocked.selector);
}
}
royaltyManager = _royaltyManager;
emit RoyaltyManagerChanged(_royaltyManager);
observability.emitRoyaltyManagerChanged(_royaltyManager);
}
/**
* @notice Removes royalty manager if current one allows it
*/
function removeRoyaltyManager() external nonReentrant {
address msgSender = _msgSender();
address currentRoyaltyManager = royaltyManager;
if (currentRoyaltyManager == address(0)) {
_revert(ManagerDoesNotExist.selector);
}
if (!IRoyaltyManager(currentRoyaltyManager).canRemoveItself(msgSender)) {
_revert(ManagerRemoveBlocked.selector);
}
royaltyManager = address(0);
emit RoyaltyManagerChanged(address(0));
observability.emitRoyaltyManagerChanged(address(0));
}
/**
* @notice Freeze mints on contract forever
*/
function freezeMints() external onlyOwner nonReentrant {
_mintFrozen = 1;
emit MintsFrozen();
observability.emitMintsFrozen();
}
/**
* @notice Return allowed minters on contract
*/
function minters() external view returns (address[] memory) {
return _minters.values();
}
/**
* @notice Conforms to ERC-2981. Editions should overwrite to return royalty for entire edition
* @param _tokenGroupingId Token id if on general, and edition id if on editions
* @param _salePrice Sale price of token
*/
function royaltyInfo(uint256 _tokenGroupingId, uint256 _salePrice)
public
view
virtual
override
returns (address receiver, uint256 royaltyAmount)
{
IRoyaltyManager.Royalty memory royalty = _royalties[_tokenGroupingId];
if (royalty.recipientAddress == address(0)) {
royalty = _defaultRoyalty;
}
receiver = royalty.recipientAddress;
royaltyAmount = (_salePrice * uint256(royalty.royaltyPercentageBPS)) / 10000;
}
/**
* @notice Returns the token manager for the id passed in.
* @param id Token ID or Edition ID for Editions implementing contracts
*/
function tokenManager(uint256 id) public view returns (address manager) {
manager = defaultManager;
address granularManager = _managers[id];
if (granularManager != address(0)) {
manager = granularManager;
}
}
/**
* @notice Initializes the contract, setting the creator as the initial owner.
* @param _creator Contract creator
* @param defaultRoyalty Default royalty for the contract
* @param _defaultTokenManager Default token manager for the contract
*/
function __ERC721Base_initialize(
address _creator,
IRoyaltyManager.Royalty memory defaultRoyalty,
address _defaultTokenManager
) internal onlyInitializing royaltyValid(defaultRoyalty.royaltyPercentageBPS) {
__Ownable_init();
__ReentrancyGuard_init();
_transferOwnership(_creator);
if (_defaultRoyalty.recipientAddress != address(0)) {
_defaultRoyalty = defaultRoyalty;
}
if (_defaultTokenManager != address(0)) {
defaultManager = _defaultTokenManager;
}
}
/**
* @notice Returns true if address is a valid tokenManager
* @param _tokenManager Token manager being checked
*/
function _isValidTokenManager(address _tokenManager) internal view returns (bool) {
return _tokenManager.supportsInterface(type(ITokenManager).interfaceId);
}
/**
* @notice Returns true if address is a valid royaltyManager
* @param _royaltyManager Royalty manager being checked
*/
function _isValidRoyaltyManager(address _royaltyManager) internal view returns (bool) {
return _royaltyManager.supportsInterface(type(IRoyaltyManager).interfaceId);
}
/**
* @notice Used for meta-transactions
*/
function _msgSender()
internal
view
virtual
override(ContextUpgradeable, ERC2771ContextUpgradeable)
returns (address sender)
{
return ERC2771ContextUpgradeable._msgSender();
}
/**
* @dev For more efficient reverts.
*/
function _revert(bytes4 errorSelector) internal pure virtual {
assembly {
mstore(0x00, errorSelector)
revert(0x00, 0x04)
}
}
/**
* @notice Used for meta-transactions
*/
function _msgData()
internal
view
virtual
override(ContextUpgradeable, ERC2771ContextUpgradeable)
returns (bytes calldata)
{
return ERC2771ContextUpgradeable._msgData();
}
/**
* @notice Returns true if royalty bps passed in is valid (<= 10000)
* @param _royaltyBPS Royalty basis points
*/
function _royaltyBPSValid(uint16 _royaltyBPS) private pure returns (bool) {
return _royaltyBPS <= 10000;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
/**
* @author highlight.xyz
* @notice If token managers implement this, transfer actions will call
* postSafeTransferFrom or postTransferFrom on the token manager.
*/
interface IPostTransfer {
/**
* @notice Hook called by community after safe transfers, if token manager of transferred token implements this
* interface.
* @param operator Operator transferring tokens
* @param from Token(s) sender
* @param to Token(s) recipient
* @param id Transferred token's id
* @param data Arbitrary data
*/
function postSafeTransferFrom(
address operator,
address from,
address to,
uint256 id,
bytes memory data
) external;
/**
* @notice Hook called by community after transfers, if token manager of transferred token implements
* this interface.
* @param operator Operator transferring tokens
* @param from Token(s) sender
* @param to Token(s) recipient
* @param id Transferred token's id
*/
function postTransferFrom(
address operator,
address from,
address to,
uint256 id
) external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
/**
* @author highlight.xyz
* @notice If token managers implement this, transfer actions will call
* postBurn on the token manager.
*/
interface IPostBurn {
/**
* @notice Hook called by contract after burn, if token manager of burned token implements this
* interface.
* @param operator Operator burning tokens
* @param sender Msg sender
* @param id Burned token's id or id of edition of token that is burned
*/
function postBurn(
address operator,
address sender,
uint256 id
) external;
}
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
/**
* @notice General721 mint interface
* @author highlight.xyz
*/
interface IERC721GeneralMint {
/**
* @notice Mint one token to one recipient
* @param recipient Recipient of minted NFT
*/
function mintOneToOneRecipient(address recipient) external returns (uint256);
/**
* @notice Mint an amount of tokens to one recipient
* @param recipient Recipient of minted NFTs
* @param amount Amount of NFTs minted
*/
function mintAmountToOneRecipient(address recipient, uint256 amount) external;
/**
* @notice Mint one token to multiple recipients. Useful for use-cases like airdrops
* @param recipients Recipients of minted NFTs
*/
function mintOneToMultipleRecipients(address[] calldata recipients) external;
/**
* @notice Mint the same amount of tokens to multiple recipients
* @param recipients Recipients of minted NFTs
* @param amount Amount of NFTs minted to each recipient
*/
function mintSameAmountToMultipleRecipients(address[] calldata recipients, uint256 amount) external;
/**
* @notice Mint a chosen token id to a single recipient
* @param recipient Recipient of chosen NFT
* @param tokenId ID of NFT to mint
*/
function mintSpecificTokenToOneRecipient(address recipient, uint256 tokenId) external;
/**
* @notice Mint chosen token ids to a single recipient
* @param recipient Recipient of chosen NFT
* @param tokenIds IDs of NFTs to mint
*/
function mintSpecificTokensToOneRecipient(address recipient, uint256[] calldata tokenIds) external;
}
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
import "./ERC721Base.sol";
import "../metadata/MetadataEncryption.sol";
import "../tokenManager/interfaces/IPostTransfer.sol";
import "../tokenManager/interfaces/IPostBurn.sol";
import "./interfaces/IERC721GeneralMint.sol";
import "../utils/ERC721/ERC721URIStorageUpgradeable.sol";
/**
* @title Generalized Base ERC721
* @author highlight.xyz
* @notice Generalized Base NFT smart contract
*/
abstract contract ERC721GeneralGenesisBase is ERC721Base, ERC721URIStorageUpgradeable, IERC721GeneralMint {
using EnumerableSet for EnumerableSet.AddressSet;
/**
* @notice Throw when attempting to mint, while mint is frozen
*/
error MintFrozen();
/**
* @notice Throw when requested token is not in range within bounds of limit supply
*/
error TokenNotInRange();
/**
* @notice Throw when new supply is over limit supply
*/
error OverLimitSupply();
/**
* @notice Throw when array lengths are mismatched
*/
error MismatchedArrayLengths();
/**
* @notice Throw when string is empty
*/
error EmptyString();
/**
* @notice Contract metadata
*/
string public contractURI;
/**
* @notice Limit the supply to take advantage of over-promising in summation with multiple mint vectors
*/
uint256 public limitSupply;
/**
* @notice Emitted when uris are set for tokens
* @param ids IDs of tokens to set uris for
* @param uris Uris to set on tokens
*/
event TokenURIsSet(uint256[] ids, string[] uris);
/**
* @notice Emitted when limit supply is set
* @param newLimitSupply Limit supply to set
*/
event LimitSupplySet(uint256 indexed newLimitSupply);
/**
* @notice See {IERC721GeneralMint-mintOneToOneRecipient}
*/
function mintOneToOneRecipient(address recipient) external onlyMinter nonReentrant returns (uint256) {
if (_mintFrozen == 1) {
_revert(MintFrozen.selector);
}
uint256 tempSupply = _nextTokenId();
_requireLimitSupply(tempSupply);
_mint(recipient, 1, tempSupply, tempSupply);
return tempSupply;
}
/**
* @notice See {IERC721GeneralMint-mintAmountToOneRecipient}
*/
function mintAmountToOneRecipient(address recipient, uint256 amount) external onlyMinter nonReentrant {
if (_mintFrozen == 1) {
_revert(MintFrozen.selector);
}
uint256 tempSupply = _nextTokenId(); // cache
_requireLimitSupply(tempSupply + amount - 1);
_mint(recipient, amount, tempSupply, tempSupply);
}
/**
* @notice See {IERC721GeneralMint-mintOneToMultipleRecipients}
*/
function mintOneToMultipleRecipients(address[] calldata recipients) external onlyMinter nonReentrant {
if (_mintFrozen == 1) {
_revert(MintFrozen.selector);
}
uint256 recipientsLength = recipients.length;
uint256 tempSupply = _nextTokenId(); // cache
for (uint256 i = 0; i < recipientsLength; i++) {
_mint(recipients[i], 1, tempSupply, tempSupply);
tempSupply++;
}
_requireLimitSupply(tempSupply - 1);
}
/**
* @notice See {IERC721GeneralMint-mintSameAmountToMultipleRecipients}
*/
function mintSameAmountToMultipleRecipients(address[] calldata recipients, uint256 amount)
external
onlyMinter
nonReentrant
{
if (_mintFrozen == 1) {
_revert(MintFrozen.selector);
}
uint256 recipientsLength = recipients.length;
uint256 tempSupply = _nextTokenId(); // cache
for (uint256 i = 0; i < recipientsLength; i++) {
_mint(recipients[i], amount, tempSupply, tempSupply);
tempSupply += amount;
}
_requireLimitSupply(tempSupply - 1);
}
/**
* @notice See {IERC721GeneralMint-mintSpecificTokenToOneRecipient}
*/
function mintSpecificTokenToOneRecipient(address recipient, uint256 tokenId) external onlyMinter nonReentrant {
if (_mintFrozen == 1) {
_revert(MintFrozen.selector);
}
uint256 _limitSupply = limitSupply;
if (_limitSupply != 0) {
if (tokenId > _limitSupply) {
_revert(TokenNotInRange.selector);
}
}
_mint(recipient, 1, tokenId, 0);
}
/**
* @notice See {IERC721GeneralMint-mintSpecificTokensToOneRecipient}
*/
function mintSpecificTokensToOneRecipient(address recipient, uint256[] calldata tokenIds)
external
onlyMinter
nonReentrant
{
if (_mintFrozen == 1) {
_revert(MintFrozen.selector);
}
uint256 tempSupply = _nextTokenId();
uint256 tokenIdsLength = tokenIds.length;
uint256 _limitSupply = limitSupply;
if (_limitSupply == 0) {
// don't check that token id is within range, since _limitSupply being 0 implies unlimited range
for (uint256 i = 0; i < tokenIdsLength; i++) {
_mint(recipient, 1, tokenIds[i], tempSupply);
tempSupply++;
}
} else {
// check that token id is within range
for (uint256 i = 0; i < tokenIdsLength; i++) {
if (tokenIds[i] > _limitSupply) {
_revert(TokenNotInRange.selector);
}
_mint(recipient, 1, tokenIds[i], tempSupply);
tempSupply++;
}
}
}
/**
* @notice Override base URI system for select tokens, with custom per-token metadata
* @param ids IDs of tokens to override base uri system for with custom uris
* @param uris Custom uris
*/
function setTokenURIs(uint256[] calldata ids, string[] calldata uris) external nonReentrant {
uint256 idsLength = ids.length;
if (idsLength != uris.length) {
_revert(MismatchedArrayLengths.selector);
}
for (uint256 i = 0; i < idsLength; i++) {
_setTokenURI(ids[i], uris[i]);
}
emit TokenURIsSet(ids, uris);
observability.emitTokenURIsSet(ids, uris);
}
/**
* @notice Set base uri
* @param newBaseURI New base uri to set
*/
function setBaseURI(string calldata newBaseURI) external nonReentrant {
if (bytes(newBaseURI).length == 0) {
_revert(EmptyString.selector);
}
address _manager = defaultManager;
if (_manager == address(0)) {
if (_msgSender() != owner()) {
_revert(Unauthorized.selector);
}
} else {
if (!ITokenManager(_manager).canUpdateMetadata(_msgSender(), 0, bytes(newBaseURI))) {
_revert(Unauthorized.selector);
}
}
_setBaseURI(newBaseURI);
observability.emitBaseUriSet(newBaseURI);
}
/**
* @notice Set limit supply
* @param _limitSupply Limit supply to set
*/
function setLimitSupply(uint256 _limitSupply) external onlyOwner nonReentrant {
// allow it to be 0, for post-mint
limitSupply = _limitSupply;
emit LimitSupplySet(_limitSupply);
observability.emitLimitSupplySet(_limitSupply);
}
/**
* @notice Set contract name
* @param newName New name
* @param newSymbol New symbol
* @param newContractUri New contractURI
*/
function setContractMetadata(
string calldata newName,
string calldata newSymbol,
string calldata newContractUri
) external onlyOwner {
_setContractMetadata(newName, newSymbol);
contractURI = newContractUri;
observability.emitContractMetadataSet(newName, newSymbol, newContractUri);
}
/**
* @notice Hook called after transfers
* @param from Account token is being transferred from
* @param to Account token is being transferred to
* @param tokenId ID of token being transferred
*/
function _afterTokenTransfers(
address from,
address to,
uint256 tokenId
) internal override {
address msgSender = _msgSender();
address _manager = tokenManager(tokenId);
if (_manager != address(0) && IERC165Upgradeable(_manager).supportsInterface(type(IPostTransfer).interfaceId)) {
IPostTransfer(_manager).postSafeTransferFrom(msgSender, from, to, tokenId, "");
}
observability.emitTransfer(from, to, tokenId);
}
/**
* @notice See {IERC721-burn}. Overrides default behaviour to check associated tokenManager.
*/
function burn(uint256 tokenId) public nonReentrant {
address _manager = tokenManager(tokenId);
address msgSender = _msgSender();
if (_manager != address(0) && IERC165Upgradeable(_manager).supportsInterface(type(IPostBurn).interfaceId)) {
address owner = ownerOf(tokenId);
IPostBurn(_manager).postBurn(msgSender, owner, tokenId);
} else {
// default to restricting burn to owner or operator if a valid TM isn't present
if (!_isApprovedOrOwner(msgSender, tokenId)) {
_revert(Unauthorized.selector);
}
}
_burn(tokenId);
observability.emitTransfer(msgSender, address(0), tokenId);
}
/**
* @notice Overrides tokenURI to first rotate the token id
* @param tokenId ID of token to get uri for
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
return ERC721URIStorageUpgradeable.tokenURI(tokenId);
}
/**
* @notice See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165Upgradeable, ERC721AUpgradeable)
returns (bool)
{
return ERC721AUpgradeable.supportsInterface(interfaceId);
}
/**
* @notice Used for meta-transactions
*/
function _msgSender() internal view override(ERC721Base) returns (address sender) {
return ERC2771ContextUpgradeable._msgSender();
}
/**
* @notice Used for meta-transactions
*/
function _msgData() internal view override(ERC721Base) returns (bytes calldata) {
return ERC2771ContextUpgradeable._msgData();
}
/**
* @dev For more efficient reverts.
*/
function _revert(bytes4 errorSelector) internal pure override(ERC721AUpgradeable, ERC721Base) {
ERC721AUpgradeable._revert(errorSelector);
}
/**
* @notice Override base URI system for select tokens, with custom per-token metadata
* @param tokenId Token to set uri for
* @param _uri Uri to set on token
*/
function _setTokenURI(uint256 tokenId, string calldata _uri) private {
address _manager = tokenManager(tokenId);
address msgSender = _msgSender();
address tempOwner = owner();
if (_manager == address(0)) {
if (msgSender != tempOwner) {
_revert(Unauthorized.selector);
}
} else {
if (!ITokenManager(_manager).canUpdateMetadata(msgSender, tokenId, bytes(_uri))) {
_revert(Unauthorized.selector);
}
}
_tokenURIs[tokenId] = _uri;
}
/**
* @notice Require the new supply of tokens after mint to be less than limit supply
* @param newSupply New supply
*/
function _requireLimitSupply(uint256 newSupply) private view {
uint256 _limitSupply = limitSupply;
if (_limitSupply != 0 && newSupply > _limitSupply) {
_revert(OverLimitSupply.selector);
}
}
}
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
/**
* @title IRoyaltyManager
* @author highlight.xyz
* @notice Enables interfacing with custom royalty managers that define conditions on setting royalties for
* NFT contracts
*/
interface IRoyaltyManager {
/**
* @notice Struct containing values required to adhere to ERC-2981
* @param recipientAddress Royalty recipient - can be EOA, royalty splitter contract, etc.
* @param royaltyPercentageBPS Royalty cut, in basis points
*/
struct Royalty {
address recipientAddress;
uint16 royaltyPercentageBPS;
}
/**
* @notice Defines conditions around being able to swap royalty manager for another one
* @param newRoyaltyManager New royalty manager being swapped in
* @param sender msg sender
*/
function canSwap(address newRoyaltyManager, address sender) external view returns (bool);
/**
* @notice Defines conditions around being able to remove current royalty manager
* @param sender msg sender
*/
function canRemoveItself(address sender) external view returns (bool);
/**
* @notice Defines conditions around being able to set granular royalty (per token or per edition)
* @param id Edition / token ID whose royalty is being set
* @param royalty Royalty being set
* @param sender msg sender
*/
function canSetGranularRoyalty(
uint256 id,
Royalty calldata royalty,
address sender
) external view returns (bool);
/**
* @notice Defines conditions around being able to set default royalty
* @param royalty Royalty being set
* @param sender msg sender
*/
function canSetDefaultRoyalty(Royalty calldata royalty, address sender) external view returns (bool);
}
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
/**
* @title ITokenManager
* @author highlight.xyz
* @notice Enables interfacing with custom token managers
*/
interface ITokenManager {
/**
* @notice Returns whether metadata updater is allowed to update
* @param sender Updater
* @param id Token/edition who's uri is being updated
* If id is 0, implementation should decide behaviour for base uri update
* @param newData Token's new uri if called by general contract, and any metadata field if called by editions
* @return If invocation can update metadata
*/
function canUpdateMetadata(
address sender,
uint256 id,
bytes calldata newData
) external returns (bool);
/**
* @notice Returns whether token manager can be swapped for another one by invocator
* @notice Default token manager implementations should ignore id
* @param sender Swapper
* @param id Token grouping id (token id or edition id)
* @param newTokenManager New token manager being swapped to
* @return If invocation can swap token managers
*/
function canSwap(
address sender,
uint256 id,
address newTokenManager
) external returns (bool);
/**
* @notice Returns whether token manager can be removed
* @notice Default token manager implementations should ignore id
* @param sender Swapper
* @param id Token grouping id (token id or edition id)
* @return If invocation can remove token manager
*/
function canRemoveItself(address sender, uint256 id) external returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity 0.8.10;
import "@openzeppelin/contracts/utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
/* solhint-disable */
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981Upgradeable.sol)
pragma solidity 0.8.10;
import "../ERC165/IERC165Upgradeable.sol";
/**
* @dev Interface for the NFT Royalty Standard.
*
* A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
* support for royalty payments across all NFT marketplaces and ecosystem participants.
*
* _Available since v4.5._
*/
interface IERC2981Upgradeable is IERC165Upgradeable {
/**
* @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
* exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Checker.sol)
pragma solidity 0.8.10;
import "./IERC165Upgradeable.sol";
/**
* @dev Library used to query support of an interface declared via {IERC165}.
*
* Note that these functions return the actual result of the query: they do not
* `revert` if an interface is not supported. It is up to the caller to decide
* what to do in these cases.
*/
/* solhint-disable */
library ERC165CheckerUpgradeable {
// As per the EIP-165 spec, no interface should ever match 0xffffffff
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
/**
* @dev Returns true if `account` supports the {IERC165} interface,
*/
function supportsERC165(address account) internal view returns (bool) {
// Any contract that implements ERC165 must explicitly indicate support of
// InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
return
supportsERC165InterfaceUnchecked(account, type(IERC165Upgradeable).interfaceId) &&
!supportsERC165InterfaceUnchecked(account, _INTERFACE_ID_INVALID);
}
/**
* @dev Returns true if `account` supports the interface defined by
* `interfaceId`. Support for {IERC165} itself is queried automatically.
*
* See {IERC165-supportsInterface}.
*/
function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
// query support of both ERC165 as per the spec and support of _interfaceId
return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId);
}
/**
* @dev Returns a boolean array where each value corresponds to the
* interfaces passed in and whether they're supported or not. This allows
* you to batch check interfaces for a contract where your expectation
* is that some interfaces may not be supported.
*
* See {IERC165-supportsInterface}.
*
* _Available since v3.4._
*/
function getSupportedInterfaces(address account, bytes4[] memory interfaceIds)
internal
view
returns (bool[] memory)
{
// an array of booleans corresponding to interfaceIds and whether they're supported or not
bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);
// query support of ERC165 itself
if (supportsERC165(account)) {
// query support of each interface in interfaceIds
for (uint256 i = 0; i < interfaceIds.length; i++) {
interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]);
}
}
return interfaceIdsSupported;
}
/**
* @dev Returns true if `account` supports all the interfaces defined in
* `interfaceIds`. Support for {IERC165} itself is queried automatically.
*
* Batch-querying can lead to gas savings by skipping repeated checks for
* {IERC165} support.
*
* See {IERC165-supportsInterface}.
*/
function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
// query support of ERC165 itself
if (!supportsERC165(account)) {
return false;
}
// query support of each interface in _interfaceIds
for (uint256 i = 0; i < interfaceIds.length; i++) {
if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) {
return false;
}
}
// all interfaces supported
return true;
}
/**
* @notice Query if a contract implements an interface, does not check ERC165 support
* @param account The address of the contract to query for support of an interface
* @param interfaceId The interface identifier, as specified in ERC-165
* @return true if the contract at account indicates support of the interface with
* identifier interfaceId, false otherwise
* @dev Assumes that account contains a contract that supports ERC165, otherwise
* the behavior of this method is undefined. This precondition can be checked
* with {supportsERC165}.
* Interface identification is specified in ERC-165.
*/
function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) {
// prepare call
bytes memory encodedParams = abi.encodeWithSelector(IERC165Upgradeable.supportsInterface.selector, interfaceId);
// perform static call
bool success;
uint256 returnSize;
uint256 returnValue;
assembly {
success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20)
returnSize := returndatasize()
returnValue := mload(0x00)
}
return success && returnSize >= 0x20 && returnValue > 0;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (metatx/ERC2771Context.sol)
pragma solidity 0.8.10;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
/**
* @dev Context variant with ERC2771 support.
* Openzeppelin contract slightly modified by ishan@ highlight.xyz to be upgradeable.
*/
abstract contract ERC2771ContextUpgradeable is Initializable {
address private _trustedForwarder;
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
function isTrustedForwarder(address forwarder) public view virtual returns (bool) {
return forwarder == _trustedForwarder;
}
function __ERC2771ContextUpgradeable__init__(address trustedForwarder) internal onlyInitializing {
_trustedForwarder = trustedForwarder;
}
function _msgSender() internal view virtual returns (address sender) {
if (isTrustedForwarder(msg.sender)) {
// The assembly code is more direct than the Solidity version using `abi.decode`.
/* solhint-disable no-inline-assembly */
assembly {
sender := shr(96, calldataload(sub(calldatasize(), 20)))
}
/* solhint-enable no-inline-assembly */
} else {
return msg.sender;
}
}
function _msgData() internal view virtual returns (bytes calldata) {
if (isTrustedForwarder(msg.sender)) {
return msg.data[:msg.data.length - 20];
} else {
return msg.data;
}
}
}
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
import "../royaltyManager/interfaces/IRoyaltyManager.sol";
/**
* @title IObservability
* @author highlight.xyz
* @notice Interface to interact with the Highlight observability singleton
* @dev Singleton to coalesce select Highlight protocol events
*/
interface IObservability {
/**************************
ERC721Base / ERC721MinimizedBase events
**************************/
/**
* @notice Emitted when minter is registered or unregistered
* @param contractAddress Initial contract that emitted event
* @param minter Minter that was changed
* @param registered True if the minter was registered, false if unregistered
*/
event MinterRegistrationChanged(address indexed contractAddress, address indexed minter, bool indexed registered);
/**
* @notice Emitted when token managers are set for token/edition ids
* @param contractAddress Initial contract that emitted event
* @param _ids Edition / token ids
* @param _tokenManagers Token managers to set for tokens / editions
*/
event GranularTokenManagersSet(address indexed contractAddress, uint256[] _ids, address[] _tokenManagers);
/**
* @notice Emitted when token managers are removed for token/edition ids
* @param contractAddress Initial contract that emitted event
* @param _ids Edition / token ids to remove token managers for
*/
event GranularTokenManagersRemoved(address indexed contractAddress, uint256[] _ids);
/**
* @notice Emitted when default token manager changed
* @param contractAddress Initial contract that emitted event
* @param newDefaultTokenManager New default token manager. Zero address if old one was removed
*/
event DefaultTokenManagerChanged(address indexed contractAddress, address indexed newDefaultTokenManager);
/**
* @notice Emitted when default royalty is set
* @param contractAddress Initial contract that emitted event
* @param recipientAddress Royalty recipient
* @param royaltyPercentageBPS Percentage of sale (in basis points) owed to royalty recipient
*/
event DefaultRoyaltySet(
address indexed contractAddress,
address indexed recipientAddress,
uint16 indexed royaltyPercentageBPS
);
/**
* @notice Emitted when royalties are set for edition / token ids
* @param contractAddress Initial contract that emitted event
* @param ids Token / edition ids
* @param _newRoyalties New royalties for each token / edition
*/
event GranularRoyaltiesSet(address indexed contractAddress, uint256[] ids, IRoyaltyManager.Royalty[] _newRoyalties);
/**
* @notice Emitted when royalty manager is updated
* @param contractAddress Initial contract that emitted event
* @param newRoyaltyManager New royalty manager. Zero address if old one was removed
*/
event RoyaltyManagerChanged(address indexed contractAddress, address indexed newRoyaltyManager);
/**
* @notice Emitted when mints are frozen permanently
* @param contractAddress Initial contract that emitted event
*/
event MintsFrozen(address indexed contractAddress);
/**
* @notice Emitted when contract metadata is set
* @param contractAddress Initial contract that emitted event
* @param name New name
* @param symbol New symbol
* @param contractURI New contract uri
*/
event ContractMetadataSet(address indexed contractAddress, string name, string symbol, string contractURI);
/**************************
ERC721General events
**************************/
/**
* @notice Emitted when hashed metadata config is set
* @param contractAddress Initial contract that emitted event
* @param hashedURIData Hashed uri data
* @param hashedRotationData Hashed rotation key
* @param _supply Supply of tokens to mint w/ reveal
*/
event HashedMetadataConfigSet(
address indexed contractAddress,
bytes hashedURIData,
bytes hashedRotationData,
uint256 indexed _supply
);
/**
* @notice Emitted when metadata is revealed
* @param contractAddress Initial contract that emitted event
* @param key Key used to decode hashed data
* @param newRotationKey Actual rotation key to be used
*/
event Revealed(address indexed contractAddress, bytes key, uint256 newRotationKey);
/**************************
ERC721GeneralBase events
**************************/
/**
* @notice Emitted when uris are set for tokens
* @param contractAddress Initial contract that emitted event
* @param ids IDs of tokens to set uris for
* @param uris Uris to set on tokens
*/
event TokenURIsSet(address indexed contractAddress, uint256[] ids, string[] uris);
/**
* @notice Emitted when limit supply is set
* @param contractAddress Initial contract that emitted event
* @param newLimitSupply Limit supply to set
*/
event LimitSupplySet(address indexed contractAddress, uint256 indexed newLimitSupply);
/**************************
ERC721StorageUri events
**************************/
/**
* @notice Emits when a series collection has its base uri set
* @param contractAddress Contract with updated base uri
* @param newBaseUri New base uri
*/
event BaseUriSet(address indexed contractAddress, string newBaseUri);
/**************************
ERC721Editions / ERC721SingleEdition events
**************************/
// Not adding EditionCreated, EditionMintedToOneRecipient, EditionMintedToRecipients
// EditionCreated - handled by MetadataInitialized
// EditionMintedToOneRecipient / EditionMintedToRecipients - handled via mint module events
/**************************
Deployment events
**************************/
/**
* @notice Emitted when Generative Series contract is deployed
* @param deployer Contract deployer
* @param contractAddress Address of contract that was deployed
*/
event GenerativeSeriesDeployed(address indexed deployer, address indexed contractAddress);
/**
* @notice Emitted when Series contract is deployed
* @param deployer Contract deployer
* @param contractAddress Address of contract that was deployed
*/
event SeriesDeployed(address indexed deployer, address indexed contractAddress);
/**
* @notice Emitted when MultipleEditions contract is deployed
* @param deployer Contract deployer
* @param contractAddress Address of contract that was deployed
*/
event MultipleEditionsDeployed(address indexed deployer, address indexed contractAddress);
/**
* @notice Emitted when SingleEdition contract is deployed
* @param deployer Contract deployer
* @param contractAddress Address of contract that was deployed
*/
event SingleEditionDeployed(address indexed deployer, address indexed contractAddress);
/**************************
ERC721 events
**************************/
/**
* @notice Emitted when `tokenId` token is transferred from `from` to `to` on contractAddress
* @param contractAddress NFT contract token resides on
* @param from Token sender
* @param to Token receiver
* @param tokenId Token being sent
*/
event Transfer(address indexed contractAddress, address indexed from, address to, uint256 indexed tokenId);
/**
* @notice Emit MinterRegistrationChanged
*/
function emitMinterRegistrationChanged(address minter, bool registered) external;
/**
* @notice Emit GranularTokenManagersSet
*/
function emitGranularTokenManagersSet(uint256[] calldata _ids, address[] calldata _tokenManagers) external;
/**
* @notice Emit GranularTokenManagersRemoved
*/
function emitGranularTokenManagersRemoved(uint256[] calldata _ids) external;
/**
* @notice Emit DefaultTokenManagerChanged
*/
function emitDefaultTokenManagerChanged(address newDefaultTokenManager) external;
/**
* @notice Emit DefaultRoyaltySet
*/
function emitDefaultRoyaltySet(address recipientAddress, uint16 royaltyPercentageBPS) external;
/**
* @notice Emit GranularRoyaltiesSet
*/
function emitGranularRoyaltiesSet(uint256[] calldata ids, IRoyaltyManager.Royalty[] calldata _newRoyalties)
external;
/**
* @notice Emit RoyaltyManagerChanged
*/
function emitRoyaltyManagerChanged(address newRoyaltyManager) external;
/**
* @notice Emit MintsFrozen
*/
function emitMintsFrozen() external;
/**
* @notice Emit ContractMetadataSet
*/
function emitContractMetadataSet(
string calldata name,
string calldata symbol,
string calldata contractURI
) external;
/**
* @notice Emit HashedMetadataConfigSet
*/
function emitHashedMetadataConfigSet(
bytes calldata hashedURIData,
bytes calldata hashedRotationData,
uint256 _supply
) external;
/**
* @notice Emit Revealed
*/
function emitRevealed(bytes calldata key, uint256 newRotationKey) external;
/**
* @notice Emit TokenURIsSet
*/
function emitTokenURIsSet(uint256[] calldata ids, string[] calldata uris) external;
/**
* @notice Emit LimitSupplySet
*/
function emitLimitSupplySet(uint256 newLimitSupply) external;
/**
* @notice Emit BaseUriSet
*/
function emitBaseUriSet(string calldata newBaseUri) external;
/**
* @notice Emit GenerativeSeriesDeployed
*/
function emitGenerativeSeriesDeployed(address contractAddress) external;
/**
* @notice Emit SeriesDeployed
*/
function emitSeriesDeployed(address contractAddress) external;
/**
* @notice Emit MultipleEditionsDeployed
*/
function emitMultipleEditionsDeployed(address contractAddress) external;
/**
* @notice Emit SingleEditionDeployed
*/
function emitSingleEditionDeployed(address contractAddress) external;
/**
* @notice Emit Transfer
*/
function emitTransfer(
address from,
address to,
uint256 tokenId
) external;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol)
pragma solidity ^0.8.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*
* [WARNING]
* ====
* Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable.
* See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
*
* In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet.
* ====
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
// Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastValue;
// Update the index for the moved value
set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
return _values(set._inner);
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuardUpgradeable is Initializable {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity 0.8.10;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
/* solhint-disable */
interface IERC165Upgradeable {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.
*/
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original
* initialization step. This is essential to configure modules that are added through upgrades and that require
* initialization.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*/
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*/
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
/**
* @dev Utilities for metadata encryption and decryption
* @author highlight.xyz
*/
abstract contract MetadataEncryption {
/// @dev See: https://ethereum.stackexchange.com/questions/69825/decrypt-message-on-chain
function encryptDecrypt(bytes memory data, bytes calldata key) public pure returns (bytes memory result) {
// Store data length on stack for later use
uint256 length = data.length;
// solhint-disable-next-line no-inline-assembly
assembly {
// Set result to free memory pointer
result := mload(0x40)
// Increase free memory pointer by lenght + 32
mstore(0x40, add(add(result, length), 32))
// Set result length
mstore(result, length)
}
// Iterate over the data stepping by 32 bytes
for (uint256 i = 0; i < length; i += 32) {
// Generate hash of the key and offset
bytes32 hash = keccak256(abi.encodePacked(key, i));
bytes32 chunk;
// solhint-disable-next-line no-inline-assembly
assembly {
// Read 32-bytes data chunk
chunk := mload(add(data, add(i, 32)))
}
// XOR the chunk with hash
chunk ^= hash;
// solhint-disable-next-line no-inline-assembly
assembly {
// Write 32-byte encrypted chunk
mstore(add(result, add(i, 32)), chunk)
}
}
}
function _sliceUint(bytes memory bs, uint256 start) internal pure returns (uint256) {
require(bs.length >= start + 32, "slicing out of range");
uint256 x;
assembly {
x := mload(add(bs, add(0x20, start)))
}
return x;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/extensions/ERC721URIStorage.sol)
pragma solidity 0.8.10;
import "../../erc721/erc721a/ERC721AUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
/**
* @title Appending URI storage utilities onto template ERC721 contract
* @author highlight.xyz and OpenZeppelin
* @dev ERC721 token with storage based token URI management. OpenZeppelin template edited by Highlight
*/
/* solhint-disable */
abstract contract ERC721URIStorageUpgradeable is Initializable, ERC721AUpgradeable {
/**
* @notice Throw when token doesn't exist
*/
error TokenDoesNotExist();
function __ERC721URIStorage_init() internal onlyInitializing {}
function __ERC721URIStorage_init_unchained() internal onlyInitializing {}
using StringsUpgradeable for uint256;
// Optional mapping for token URIs
mapping(uint256 => string) internal _tokenURIs;
/**
* @dev Hashed rotation key data
*/
bytes internal _hashedRotationKeyData;
/**
* @dev Hashed base uri data
*/
bytes internal _hashedBaseURIData;
/**
* @dev Rotation key
*/
uint256 internal _rotationKey;
/**
* @dev Contract baseURI
*/
string public baseURI;
/**
@notice Emitted when base uri is set
* @param oldBaseUri Old base uri
* @param newBaseURI New base uri
*/
event BaseURISet(string oldBaseUri, string newBaseURI);
/**
* @dev Set contract baseURI
*/
function _setBaseURI(string memory newBaseURI) internal {
emit BaseURISet(baseURI, newBaseURI);
baseURI = newBaseURI;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if (!_exists(tokenId)) {
_revert(TokenDoesNotExist.selector);
}
string memory _tokenURI = _tokenURIs[tokenId];
// If there is no token URI, return the base URI.
if (bytes(_tokenURI).length == 0) {
return super.tokenURI(tokenId);
}
return _tokenURI;
}
/**
* @dev See {ERC721-_burn}. This override additionally checks to see if a
* token-specific URI was set for the token, and if so, it deletes the token URI from
* the storage mapping.
*/
function _burn(uint256 tokenId) internal virtual override {
super._burn(tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
function _baseURI() internal view override returns (string memory) {
return baseURI;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Chiru Labs
pragma solidity 0.8.10;
/** solhint-disable */
import "./IERC721AUpgradeable.sol";
import { ERC721AStorage } from "./ERC721AStorage.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
/**
* @dev Interface of ERC721 token receiver.
*/
interface ERC721A__IERC721ReceiverUpgradeable {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
/**
* @title ERC721AHL
* @ author: Chiru Labs, modified by [email protected]
* (mainly to store mint quantity data in extra bits per packed ownership)
*
* @dev Implementation of the [ERC721](https://eips.ethereum.org/EIPS/eip-721)
* Non-Fungible Token Standard, including the Metadata extension.
* Optimized for lower gas during batch mints.
*
* Token IDs are minted in sequential order (e.g. 0, 1, 2, 3, ...)
* starting from `_startTokenId()`.
*
* Assumptions:
*
* - An owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
* - The maximum token ID cannot exceed 2**256 - 1 (max value of uint256).
*/
contract ERC721AUpgradeable is Initializable, IERC721AUpgradeable {
using ERC721AStorage for ERC721AStorage.Layout;
using StringsUpgradeable for uint256;
// =============================================================
// CONSTANTS
// =============================================================
// Mask of an entry in packed address data.
uint256 private constant _BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;
// The bit position of `numberMinted` in packed address data.
uint256 private constant _BITPOS_NUMBER_MINTED = 64;
// The bit position of `numberBurned` in packed address data.
uint256 private constant _BITPOS_NUMBER_BURNED = 128;
// The bit position of `aux` in packed address data.
uint256 private constant _BITPOS_AUX = 192;
// Mask of all 256 bits in packed address data except the 64 bits for `aux`.
uint256 private constant _BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;
// The bit position of `startTimestamp` in packed ownership.
uint256 private constant _BITPOS_START_TIMESTAMP = 160;
// The bit mask of the `burned` bit in packed ownership.
uint256 private constant _BITMASK_BURNED = 1 << 224;
// The bit position of the `nextInitialized` bit in packed ownership.
uint256 private constant _BITPOS_NEXT_INITIALIZED = 225;
// The bit mask of the `nextInitialized` bit in packed ownership.
uint256 private constant _BITMASK_NEXT_INITIALIZED = 1 << 225;
// The bit position of `extraData` in packed ownership.
uint256 private constant _BITPOS_EXTRA_DATA = 232;
// Mask of all 256 bits in a packed ownership except the 24 bits for `extraData`.
uint256 private constant _BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;
// The mask of the lower 160 bits for addresses.
uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;
uint256 private constant _UINT_24_MAX = 16777216;
// The `Transfer` event signature is given by:
// `keccak256(bytes("Transfer(address,address,uint256)"))`.
bytes32 private constant _TRANSFER_EVENT_SIGNATURE =
0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
// =============================================================
// CONSTRUCTOR
// =============================================================
function __ERC721A_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC721A_init_unchained(name_, symbol_);
}
function __ERC721A_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
ERC721AStorage.layout()._name = name_;
ERC721AStorage.layout()._symbol = symbol_;
ERC721AStorage.layout()._currentIndex = _startTokenId();
}
/**
* @dev Hook that is called after a set of serially-ordered token IDs
* have been transferred.
*
* `startTokenId` - the first token ID to be transferred.
*
* Calling conditions:
*
* - `from` and `to` are both non-zero, since this is only invoked ont transfers
*/
function _afterTokenTransfers(
address from,
address to,
uint256 tokenId
) internal virtual {}
/**
* @dev Added by Highlight to facilitate updating of name and symbol
*/
function _setContractMetadata(string calldata newName, string calldata newSymbol) internal {
ERC721AStorage.layout()._name = newName;
ERC721AStorage.layout()._symbol = newSymbol;
}
// =============================================================
// TOKEN COUNTING OPERATIONS
// =============================================================
/**
* @dev Returns the starting token ID.
* To change the starting token ID, please override this function.
*/
function _startTokenId() internal view virtual returns (uint256) {
return 1;
}
/**
* @dev Returns the next token ID to be minted.
*/
function _nextTokenId() internal view virtual returns (uint256) {
return ERC721AStorage.layout()._currentIndex;
}
/**
* @dev Returns the total number of tokens in existence.
* Burned tokens will reduce the count.
* To get the total number of tokens minted, please see {_totalMinted}.
*/
function totalSupply() external view virtual override returns (uint256) {
// Counter underflow is impossible as _burnCounter cannot be incremented
// more than `_currentIndex - _startTokenId()` times.
unchecked {
return ERC721AStorage.layout()._currentIndex - ERC721AStorage.layout()._burnCounter - _startTokenId();
}
}
/**
* @dev Returns the total amount of tokens minted in the contract.
*/
function _totalMinted() internal view virtual returns (uint256) {
// Counter underflow is impossible as `_currentIndex` does not decrement,
// and it is initialized to `_startTokenId()`.
unchecked {
return ERC721AStorage.layout()._currentIndex - _startTokenId();
}
}
/**
* @dev Returns the total number of tokens burned.
*/
function _totalBurned() internal view virtual returns (uint256) {
return ERC721AStorage.layout()._burnCounter;
}
// =============================================================
// ADDRESS DATA OPERATIONS
// =============================================================
/**
* @dev Returns the number of tokens in `owner`'s account.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
if (owner == address(0)) _revert(BalanceQueryForZeroAddress.selector);
return ERC721AStorage.layout()._packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
}
/**
* Returns the number of tokens minted by `owner`.
*/
function _numberMinted(address owner) internal view returns (uint256) {
return
(ERC721AStorage.layout()._packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) & _BITMASK_ADDRESS_DATA_ENTRY;
}
/**
* Returns the number of tokens burned by or on behalf of `owner`.
*/
function _numberBurned(address owner) internal view returns (uint256) {
return
(ERC721AStorage.layout()._packedAddressData[owner] >> _BITPOS_NUMBER_BURNED) & _BITMASK_ADDRESS_DATA_ENTRY;
}
/**
* Returns the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
*/
function _getAux(address owner) internal view returns (uint64) {
return uint64(ERC721AStorage.layout()._packedAddressData[owner] >> _BITPOS_AUX);
}
/**
* Sets the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
* If there are multiple variables, please pack them into a uint64.
*/
function _setAux(address owner, uint64 aux) internal virtual {
uint256 packed = ERC721AStorage.layout()._packedAddressData[owner];
uint256 auxCasted;
// Cast `aux` with assembly to avoid redundant masking.
assembly {
auxCasted := aux
}
packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);
ERC721AStorage.layout()._packedAddressData[owner] = packed;
}
// =============================================================
// IERC165
// =============================================================
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
* to learn more about how these ids are created.
*
* This function call must use less than 30000 gas.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
// The interface IDs are constants representing the first 4 bytes
// of the XOR of all function selectors in the interface.
// See: [ERC165](https://eips.ethereum.org/EIPS/eip-165)
// (e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`)
return
interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
}
// =============================================================
// IERC721Metadata
// =============================================================
/**
* @dev Returns the token collection name.
*/
function name() public view virtual override returns (string memory) {
return ERC721AStorage.layout()._name;
}
/**
* @dev Returns the token collection symbol.
*/
function symbol() public view virtual override returns (string memory) {
return ERC721AStorage.layout()._symbol;
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if (!_exists(tokenId)) _revert(URIQueryForNonexistentToken.selector);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, "/", tokenId.toString())) : "";
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, it can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return "";
}
// =============================================================
// OWNERSHIPS OPERATIONS
// =============================================================
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
return address(uint160(_packedOwnershipOf(tokenId)));
}
/**
* @dev Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around over time.
*/
function _ownershipOf(uint256 tokenId) internal view virtual returns (TokenOwnership memory) {
return _unpackedOwnership(_packedOwnershipOf(tokenId));
}
/**
* @dev Returns the unpacked `TokenOwnership` struct at `index`.
*/
function _ownershipAt(uint256 index) internal view virtual returns (TokenOwnership memory) {
return _unpackedOwnership(ERC721AStorage.layout()._packedOwnerships[index]);
}
/**
* @dev Returns whether the ownership slot at `index` is initialized.
* An uninitialized slot does not necessarily mean that the slot has no owner.
*/
function _ownershipIsInitialized(uint256 index) internal view virtual returns (bool) {
return ERC721AStorage.layout()._packedOwnerships[index] != 0;
}
/**
* @dev Initializes the ownership slot minted at `index` for efficiency purposes.
*/
function _initializeOwnershipAt(uint256 index) internal virtual {
if (ERC721AStorage.layout()._packedOwnerships[index] == 0) {
ERC721AStorage.layout()._packedOwnerships[index] = _packedOwnershipOf(index);
}
}
/* solhint-disable code-complexity */
/**
* Returns the packed ownership data of `tokenId`.
*/
function _packedOwnershipOf(uint256 tokenId) private view returns (uint256 packed) {
if (_startTokenId() <= tokenId) {
packed = ERC721AStorage.layout()._packedOwnerships[tokenId];
// If the data at the starting slot does not exist, start the scan.
if (packed == 0) {
// adds run-time, potentially redundant, remove soon
if (!_exists(tokenId)) {
_revert(OwnerQueryForNonexistentToken.selector);
}
// current index tracks number of tokens, but we could mint certain tokens with different ids
// if (tokenId >= ERC721AStorage.layout()._currentIndex)
// _revert(OwnerQueryForNonexistentToken.selector);
// Invariant:
// There will always be an initialized ownership slot
// (i.e. `ownership.addr != address(0) && ownership.burned == false`)
// before an unintialized ownership slot
// (i.e. `ownership.addr == address(0) && ownership.burned == false`)
// Hence, `tokenId` will not underflow.
// We can directly compare the packed value.
// If the address is zero, packed will be zero.
for (;;) {
unchecked {
if (tokenId == 0) {
_revert(OwnerQueryForNonexistentToken.selector);
}
packed = ERC721AStorage.layout()._packedOwnerships[--tokenId];
}
if (packed == 0) continue;
if (packed & _BITMASK_BURNED == 0) return packed;
// Otherwise, the token is burned, and we must revert.
// This handles the case of batch burned tokens, where only the burned bit
// of the starting slot is set, and remaining slots are left uninitialized.
_revert(OwnerQueryForNonexistentToken.selector);
}
}
// Otherwise, the data exists and we can skip the scan.
// This is possible because we have already achieved the target condition.
// This saves 2143 gas on transfers of initialized tokens.
// If the token is not burned, return `packed`. Otherwise, revert.
if (packed & _BITMASK_BURNED == 0) return packed;
}
_revert(OwnerQueryForNonexistentToken.selector);
}
/* solhint-enable code-complexity */
/**
* @dev Returns the unpacked `TokenOwnership` struct from `packed`.
*/
function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
ownership.addr = address(uint160(packed));
ownership.startTimestamp = uint64(packed >> _BITPOS_START_TIMESTAMP);
ownership.burned = packed & _BITMASK_BURNED != 0;
ownership.extraData = uint24(packed >> _BITPOS_EXTRA_DATA);
}
/**
* @dev Packs ownership data into a single uint256.
*/
function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
assembly {
// Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
owner := and(owner, _BITMASK_ADDRESS)
// `owner | (block.timestamp << _BITPOS_START_TIMESTAMP) | flags`.
result := or(owner, or(shl(_BITPOS_START_TIMESTAMP, timestamp()), flags))
}
}
/**
* @dev Returns the `nextInitialized` flag set if `quantity` equals 1.
*/
function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
// For branchless setting of the `nextInitialized` flag.
assembly {
// `(quantity == 1) << _BITPOS_NEXT_INITIALIZED`.
result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))
}
}
// =============================================================
// APPROVAL OPERATIONS
// =============================================================
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account. See {ERC721A-_approve}.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
*/
function approve(address to, uint256 tokenId) public payable virtual override {
_approve(to, tokenId, true);
}
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
if (!_exists(tokenId)) _revert(ApprovalQueryForNonexistentToken.selector);
return ERC721AStorage.layout()._tokenApprovals[tokenId].value;
}
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom}
* for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
ERC721AStorage.layout()._operatorApprovals[_msgSenderERC721A()][operator] = approved;
emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
}
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return ERC721AStorage.layout()._operatorApprovals[owner][operator];
}
function _minted(uint256 tokenId) internal view virtual returns (bool result) {
if (_startTokenId() <= tokenId) {
uint256 initialTokenId = tokenId;
uint24 mintQuantity;
while (
(mintQuantity = uint24((ERC721AStorage.layout()._packedOwnerships[tokenId]) >> _BITPOS_EXTRA_DATA)) == 0
) {
// edited to avoid underflow
if (tokenId == 0) {
return false;
}
--tokenId;
}
// if the mint quantity at the number we landed at does extend to the initially queried tokenId,
// the initially queried tokenId has been minted
if (uint24(initialTokenId - tokenId) < mintQuantity) {
return true;
}
}
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted. See {_mint}.
*/
function _exists(uint256 tokenId) internal view virtual returns (bool result) {
if (_startTokenId() <= tokenId) {
uint256 packed = ERC721AStorage.layout()._packedOwnerships[tokenId];
// not burned, and minted (calculate burn first, to avoid minted call if token has been burned)
result = ((packed & _BITMASK_BURNED) == 0) && _minted(tokenId);
}
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ownerOf(tokenId);
return (isApprovedForAll(owner, spender) || _isSenderApprovedOrOwner(getApproved(tokenId), owner, spender));
}
/**
* @dev Returns whether `msgSender` is equal to `approvedAddress` or `owner`.
*/
function _isSenderApprovedOrOwner(
address approvedAddress,
address owner,
address msgSender
) private pure returns (bool result) {
assembly {
// Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
owner := and(owner, _BITMASK_ADDRESS)
// Mask `msgSender` to the lower 160 bits, in case the upper bits somehow aren't clean.
msgSender := and(msgSender, _BITMASK_ADDRESS)
// `msgSender == owner || msgSender == approvedAddress`.
result := or(eq(msgSender, owner), eq(msgSender, approvedAddress))
}
}
/**
* @dev Returns the storage slot and value for the approved address of `tokenId`.
*/
function _getApprovedSlotAndAddress(uint256 tokenId)
private
view
returns (uint256 approvedAddressSlot, address approvedAddress)
{
ERC721AStorage.TokenApprovalRef storage tokenApproval = ERC721AStorage.layout()._tokenApprovals[tokenId];
// The following is equivalent to `approvedAddress = _tokenApprovals[tokenId].value`.
assembly {
approvedAddressSlot := tokenApproval.slot
approvedAddress := sload(approvedAddressSlot)
}
}
// =============================================================
// TRANSFER OPERATIONS
// =============================================================
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token
* by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable virtual override {
uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);
// Mask `from` to the lower 160 bits, in case the upper bits somehow aren't clean.
from = address(uint160(uint256(uint160(from)) & _BITMASK_ADDRESS));
if (address(uint160(prevOwnershipPacked)) != from) _revert(TransferFromIncorrectOwner.selector);
(uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);
// The nested ifs save around 20+ gas over a compound boolean condition.
if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
if (!isApprovedForAll(from, _msgSenderERC721A())) _revert(TransferCallerNotOwnerNorApproved.selector);
// Clear approvals from the previous owner.
assembly {
if approvedAddress {
// This is equivalent to `delete _tokenApprovals[tokenId]`.
sstore(approvedAddressSlot, 0)
}
}
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.
unchecked {
// We can directly increment and decrement the balances.
--ERC721AStorage.layout()._packedAddressData[from]; // Updates: `balance -= 1`.
++ERC721AStorage.layout()._packedAddressData[to]; // Updates: `balance += 1`.
// Updates:
// - `address` to the next owner.
// - `startTimestamp` to the timestamp of transfering.
// - `burned` to `false`.
// - `nextInitialized` to `true`.
ERC721AStorage.layout()._packedOwnerships[tokenId] = _packOwnershipData(
to,
_BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked, 0)
);
// If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
uint256 nextTokenId = tokenId + 1;
// If the next slot's address is zero and not burned (i.e. packed value is zero).
if (ERC721AStorage.layout()._packedOwnerships[nextTokenId] == 0) {
// If the next slot exists
if (_minted(nextTokenId)) {
// remove extra data from this
// Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
// remove mint quantity to preserve original mint spots
ERC721AStorage.layout()._packedOwnerships[nextTokenId] = _removeExtraData(prevOwnershipPacked);
}
}
}
}
// Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
uint256 toMasked = uint256(uint160(to)) & _BITMASK_ADDRESS;
assembly {
// Emit the `Transfer` event.
log4(
0, // Start of data (0, since no data).
0, // End of data (0, since no data).
_TRANSFER_EVENT_SIGNATURE, // Signature.
from, // `from`.
toMasked, // `to`.
tokenId // `tokenId`.
)
}
if (toMasked == 0) _revert(TransferToZeroAddress.selector);
_afterTokenTransfers(from, to, tokenId);
}
/**
* @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token
* by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement
* {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public payable virtual override {
transferFrom(from, to, tokenId);
if (to.code.length != 0)
if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
_revert(TransferToNonERC721ReceiverImplementer.selector);
}
}
/**
* @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target contract.
*
* `from` - Previous owner of the given token ID.
* `to` - Target address that will receive the token.
* `tokenId` - Token ID to be transferred.
* `_data` - Optional data to send along with the call.
*
* Returns whether the call correctly returned the expected magic value.
*/
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
try
ERC721A__IERC721ReceiverUpgradeable(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data)
returns (bytes4 retval) {
return retval == ERC721A__IERC721ReceiverUpgradeable(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
_revert(TransferToNonERC721ReceiverImplementer.selector);
}
assembly {
revert(add(32, reason), mload(reason))
}
}
}
// =============================================================
// MINT OPERATIONS
// =============================================================
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event for each mint.
*/
function _mint(
address to,
uint256 quantity,
uint256 startTokenId,
uint256 currentIndex
) internal virtual {
if (quantity >= _UINT_24_MAX) {
_revert(QuantityTooLarge.selector);
}
if (currentIndex == 0) {
currentIndex = ERC721AStorage.layout()._currentIndex;
}
if (startTokenId == 0) {
startTokenId = currentIndex;
} else {
// only path that selects token ids erratically (collector's choice series) runs _mint per token,
// so no need to check _minted for consecutive token ids here
if (_minted(startTokenId)) {
_revert(TokenMintedAlready.selector);
}
}
if (quantity == 0) _revert(MintZeroQuantity.selector);
// Overflows are incredibly unrealistic.
// `balance` and `numberMinted` have a maximum limit of 2**64.
// `tokenId` has a maximum limit of 2**256.
unchecked {
// Updates:
// - `address` to the owner.
// - `startTimestamp` to the timestamp of minting.
// - `burned` to `false`.
// - `nextInitialized` to `quantity == 1`.
ERC721AStorage.layout()._packedOwnerships[startTokenId] = _packOwnershipData(
to,
_nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0, uint24(quantity))
);
// Updates:
// - `balance += quantity`.
// - `numberMinted += quantity`.
//
// We can directly add to the `balance` and `numberMinted`.
ERC721AStorage.layout()._packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);
// Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
uint256 toMasked = uint256(uint160(to)) & _BITMASK_ADDRESS;
if (toMasked == 0) _revert(MintToZeroAddress.selector);
uint256 end = startTokenId + quantity;
uint256 tokenId = startTokenId;
do {
assembly {
// Emit the `Transfer` event.
log4(
0, // Start of data (0, since no data).
0, // End of data (0, since no data).
_TRANSFER_EVENT_SIGNATURE, // Signature.
0, // `address(0)`.
toMasked, // `to`.
tokenId // `tokenId`.
)
}
// The `!=` check ensures that large values of `quantity`
// that overflows uint256 will make the loop run out of gas.
} while (++tokenId != end);
ERC721AStorage.layout()._currentIndex = currentIndex + quantity;
}
}
// =============================================================
// APPROVAL OPERATIONS
// =============================================================
/**
* @dev Equivalent to `_approve(to, tokenId, false)`.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_approve(to, tokenId, false);
}
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the
* zero address clears previous approvals.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
bool approvalCheck
) internal virtual {
address owner = ownerOf(tokenId);
if (approvalCheck && _msgSenderERC721A() != owner)
if (!isApprovedForAll(owner, _msgSenderERC721A())) {
_revert(ApprovalCallerNotOwnerNorApproved.selector);
}
ERC721AStorage.layout()._tokenApprovals[tokenId].value = to;
emit Approval(owner, to, tokenId);
}
// =============================================================
// BURN OPERATIONS
// =============================================================
/**
* @dev Equivalent to `_burn(tokenId, false)`.
*/
function _burn(uint256 tokenId) internal virtual {
_burn(tokenId, false);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);
address from = address(uint160(prevOwnershipPacked));
(uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);
if (approvalCheck) {
// The nested ifs save around 20+ gas over a compound boolean condition.
if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
if (!isApprovedForAll(from, _msgSenderERC721A())) _revert(TransferCallerNotOwnerNorApproved.selector);
}
// Clear approvals from the previous owner.
assembly {
if approvedAddress {
// This is equivalent to `delete _tokenApprovals[tokenId]`.
sstore(approvedAddressSlot, 0)
}
}
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.
unchecked {
// Updates:
// - `balance -= 1`.
// - `numberBurned += 1`.
//
// We can directly decrement the balance, and increment the number burned.
// This is equivalent to `packed -= 1; packed += 1 << _BITPOS_NUMBER_BURNED;`.
ERC721AStorage.layout()._packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;
// Updates:
// - `address` to the last owner.
// - `startTimestamp` to the timestamp of burning.
// - `burned` to `true`.
// - `nextInitialized` to `true`.
ERC721AStorage.layout()._packedOwnerships[tokenId] = _packOwnershipData(
from,
(_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked, 0)
);
// If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
uint256 nextTokenId = tokenId + 1;
// If the next slot's address is zero and not burned (i.e. packed value is zero).
if (ERC721AStorage.layout()._packedOwnerships[nextTokenId] == 0) {
// If the next slot exists
if (_minted(nextTokenId)) {
// Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
// remove mint quantity to preserve original mint spots
ERC721AStorage.layout()._packedOwnerships[nextTokenId] = _removeExtraData(prevOwnershipPacked);
}
}
}
}
emit Transfer(from, address(0), tokenId);
// Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
unchecked {
ERC721AStorage.layout()._burnCounter++;
}
}
// =============================================================
// EXTRA DATA OPERATIONS
// =============================================================
/**
* @dev Remove the extra data from a packed ownership, used to preserve original mint slots
*/
function _removeExtraData(uint256 packedOwnershipData) internal pure returns (uint256) {
return packedOwnershipData & _BITMASK_EXTRA_DATA_COMPLEMENT;
}
/**
* @dev Directly sets the extra data for the ownership data `index`.
*/
function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {
uint256 packed = ERC721AStorage.layout()._packedOwnerships[index];
if (packed == 0) _revert(OwnershipNotInitializedForExtraData.selector);
uint256 extraDataCasted;
// Cast `extraData` with assembly to avoid redundant masking.
assembly {
extraDataCasted := extraData
}
packed = (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << _BITPOS_EXTRA_DATA);
ERC721AStorage.layout()._packedOwnerships[index] = packed;
}
/**
* @dev Called during each token transfer to set the 24bit `extraData` field.
* Intended to be overridden by the cosumer contract.
*
* `previousExtraData` - the value of `extraData` before transfer.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, `tokenId` will be burned by `from`.
* - `from` and `to` are never both zero.
*/
function _extraData(
address from,
address to,
uint24 previousExtraData,
uint24 quantityMinted
) internal view virtual returns (uint24) {
if (from == address(0) && to != address(0)) {
// mint
return quantityMinted;
} else {
return previousExtraData;
}
}
/**
* @dev Returns the next extra data for the packed ownership data.
* The returned result is shifted into position.
*/
function _nextExtraData(
address from,
address to,
uint256 prevOwnershipPacked,
uint24 quantityMinted
) private view returns (uint256) {
uint24 extraData = uint24(prevOwnershipPacked >> _BITPOS_EXTRA_DATA);
return uint256(_extraData(from, to, extraData, quantityMinted)) << _BITPOS_EXTRA_DATA;
}
// =============================================================
// OTHER OPERATIONS
// =============================================================
/**
* @dev Returns the message sender (defaults to `msg.sender`).
*
* If you are writing GSN compatible contracts, you need to override this function.
*/
function _msgSenderERC721A() internal view virtual returns (address) {
return msg.sender;
}
/**
* @dev Converts a uint256 to its ASCII string decimal representation.
*/
function _toString(uint256 value) internal pure virtual returns (string memory str) {
assembly {
// The maximum value of a uint256 contains 78 digits (1 byte per digit), but
// we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
// We will need 1 word for the trailing zeros padding, 1 word for the length,
// and 3 words for a maximum of 78 digits. Total: 5 * 0x20 = 0xa0.
let m := add(mload(0x40), 0xa0)
// Update the free memory pointer to allocate.
mstore(0x40, m)
// Assign the `str` to the end.
str := sub(m, 0x20)
// Zeroize the slot after the string.
mstore(str, 0)
// Cache the end of the memory to calculate the length later.
let end := str
// We write the string from rightmost digit to leftmost digit.
// The following is essentially a do-while loop that also handles the zero case.
// prettier-ignore
for { let temp := value } 1 {} {
str := sub(str, 1)
// Write the character to the pointer.
// The ASCII index of the '0' character is 48.
mstore8(str, add(48, mod(temp, 10)))
// Keep dividing `temp` until zero.
temp := div(temp, 10)
// prettier-ignore
if iszero(temp) { break }
}
let length := sub(end, str)
// Move the pointer 32 bytes leftwards to make room for the length.
str := sub(str, 0x20)
// Store the length.
mstore(str, length)
}
}
/**
* @dev For more efficient reverts.
*/
function _revert(bytes4 errorSelector) internal pure virtual {
assembly {
mstore(0x00, errorSelector)
revert(0x00, 0x04)
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
library StringsUpgradeable {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
// SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Chiru Labs
pragma solidity 0.8.10;
/** solhint-disable */
/**
* @dev Interface of ERC721A.
* @ author Chiru Labs, slightly modified by [email protected]
*/
interface IERC721AUpgradeable {
/**
* Quantity to mint is too large
*/
error QuantityTooLarge();
/**
* Cannot re-mint token
*/
error TokenMintedAlready();
/**
* The caller must own the token or be an approved operator.
*/
error ApprovalCallerNotOwnerNorApproved();
/**
* The token does not exist.
*/
error ApprovalQueryForNonexistentToken();
/**
* Cannot query the balance for the zero address.
*/
error BalanceQueryForZeroAddress();
/**
* Cannot mint to the zero address.
*/
error MintToZeroAddress();
/**
* The quantity of tokens minted must be more than zero.
*/
error MintZeroQuantity();
/**
* The token does not exist.
*/
error OwnerQueryForNonexistentToken();
/**
* The caller must own the token or be an approved operator.
*/
error TransferCallerNotOwnerNorApproved();
/**
* The token must be owned by `from`.
*/
error TransferFromIncorrectOwner();
/**
* Cannot safely transfer to a contract that does not implement the
* ERC721Receiver interface.
*/
error TransferToNonERC721ReceiverImplementer();
/**
* Cannot transfer to the zero address.
*/
error TransferToZeroAddress();
/**
* The token does not exist.
*/
error URIQueryForNonexistentToken();
/**
* The `quantity` minted with ERC2309 exceeds the safety limit.
*/
error MintERC2309QuantityExceedsLimit();
/**
* The `extraData` cannot be set on an unintialized ownership slot.
*/
error OwnershipNotInitializedForExtraData();
// =============================================================
// STRUCTS
// =============================================================
struct TokenOwnership {
// The address of the owner.
address addr;
// Stores the start time of ownership with minimal overhead for tokenomics.
uint64 startTimestamp;
// Whether the token has been burned.
bool burned;
// Arbitrary data similar to `startTimestamp` that can be set via {_extraData}.
uint24 extraData;
}
// =============================================================
// TOKEN COUNTERS
// =============================================================
/**
* @dev Returns the total number of tokens in existence.
* Burned tokens will reduce the count.
* To get the total number of tokens minted, please see {_totalMinted}.
*/
function totalSupply() external view returns (uint256);
// =============================================================
// IERC165
// =============================================================
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
* to learn more about how these ids are created.
*
* This function call must use less than 30000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
// =============================================================
// IERC721
// =============================================================
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables
* (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in `owner`'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`,
* checking first that contract recipients are aware of the ERC721 protocol
* to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move
* this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement
* {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external payable;
/**
* @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external payable;
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom}
* whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token
* by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external payable;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the
* zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external payable;
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom}
* for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}.
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
// =============================================================
// IERC721Metadata
// =============================================================
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
/** solhint-disable */
library ERC721AStorage {
// Bypass for a `--via-ir` bug (https://github.com/chiru-labs/ERC721A/pull/364).
struct TokenApprovalRef {
address value;
}
struct Layout {
// =============================================================
// STORAGE
// =============================================================
// The next token ID to be minted.
uint256 _currentIndex;
// The number of tokens burned.
uint256 _burnCounter;
// Token name
string _name;
// Token symbol
string _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned.
// See {_packedOwnershipOf} implementation for details.
//
// Bits Layout:
// - [0..159] `addr`
// - [160..223] `startTimestamp`
// - [224] `burned`
// - [225] `nextInitialized`
// - [232..255] `extraData`
mapping(uint256 => uint256) _packedOwnerships;
// Mapping owner address to address data.
//
// Bits Layout:
// - [0..63] `balance`
// - [64..127] `numberMinted`
// - [128..191] `numberBurned`
// - [192..255] `aux`
mapping(address => uint256) _packedAddressData;
// Mapping from token ID to approved address.
mapping(uint256 => ERC721AStorage.TokenApprovalRef) _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) _operatorApprovals;
}
bytes32 internal constant _STORAGE_SLOT = keccak256("ERC721A.contracts.storage.ERC721A");
function layout() internal pure returns (Layout storage l) {
bytes32 slot = _STORAGE_SLOT;
assembly {
l.slot := slot
}
}
}