Contract Name:
CreatorBlueprintsFilterer
Contract Source Code:
//SPDX-License-Identifier: Unlicense
pragma solidity 0.8.4;
import "../../abstract/HasSecondarySaleFees.sol";
import "../../common/IBlueprintTypes.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {IOperatorFilterRegistry} from "../OperatorFilterer/operatorFilterRegistry/IOperatorFilterRegistry.sol";
/**
* @dev Async Art Blueprint NFT contract with true creator provenance
* @author Async Art, Ohimire Labs
*/
contract CreatorBlueprintsFilterer is
ERC721Upgradeable,
HasSecondarySaleFees,
AccessControlEnumerableUpgradeable,
ReentrancyGuard
{
using StringsUpgradeable for uint256;
/**
* @dev Default fee given to platform on primary sales
*/
uint32 public defaultPlatformPrimaryFeePercentage;
/**
* @dev First token ID of the next Blueprint to be prepared
*/
uint64 public latestErc721TokenIndex;
/**
* @dev Platform account receiving fees from primary sales
*/
address public asyncSaleFeesRecipient;
/**
* @dev Account representing platform
*/
address public platform;
/**
* @dev Account able to perform actions restricted to MINTER_ROLE holder
*/
address public minterAddress;
/**
* @dev Blueprint artist
*/
address public artist;
/**
* @dev Tracks failed transfers of native gas token
*/
mapping(address => uint256) failedTransferCredits;
/**
* @dev Blueprint, core object of contract
*/
Blueprints public blueprint;
/**
* @dev Royalty config
*/
RoyaltyParameters public royaltyParameters;
/**
* @dev Contract-level metadata
*/
string public contractURI;
/**
* @dev Holders of this role are given minter privileges
*/
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
/*
* @dev A mapping from whitelisted addresses to amout of pre-sale blueprints purchased
* @dev This is seperate from the Blueprint struct because it was introduced as part of an upgrade, and needs to be placed at the end of storage to avoid overwriting.
*/
mapping(address => uint32) whitelistedPurchases;
/**
* @dev A registry to check for blacklisted operator addresses. Used to only permit marketplaces enforcing creator royalites if desired
*/
IOperatorFilterRegistry public operatorFilterRegistry;
/**
* @dev Tracks state of Blueprint sale
*/
enum SaleState {
not_prepared,
not_started,
started,
paused
}
/**
* @dev Object holding royalty data
* @param split Royalty splitter receiving royalties
* @param royaltyCutBPS Total percentage of token sales sent to split, in basis points
*/
struct RoyaltyParameters {
address split;
uint32 royaltyCutBPS;
}
/**
* @dev Blueprint
* @param mintAmountArtist Amount of NFTs of Blueprint mintable by artist
* @param mintAmountPlatform Amount of NFTs of Blueprint mintable by platform
* @param capacity Number of NFTs in Blueprint
* @param erc721TokenIndex First token ID of the next Blueprint to be prepared
* @param maxPurchaseAmount Max number of NFTs purchasable in a single transaction
* @param saleEndTimestamp Timestamp when the sale ends
* @param price Price per NFT in Blueprint
* @param tokenUriLocked If the token metadata isn't updatable
* @param ERC20Token Address of ERC20 currency required to buy NFTs, can be zero address if expected currency is native gas token
* @param baseTokenUri Base URI for token, resultant uri for each token is base uri concatenated with token id
* @param merkleroot Root of Merkle tree holding whitelisted accounts
* @param saleState State of sale
* @param feeRecipientInfo Object containing primary and secondary fee configuration
*/
struct Blueprints {
uint32 mintAmountArtist;
uint32 mintAmountPlatform;
uint64 capacity;
uint64 erc721TokenIndex;
uint64 maxPurchaseAmount;
uint128 saleEndTimestamp;
uint128 price;
bool tokenUriLocked;
address ERC20Token;
string baseTokenUri;
bytes32 merkleroot;
SaleState saleState;
IBlueprintTypes.PrimaryFees feeRecipientInfo;
}
/**
* @dev Creator config of contract
* @param name Contract name
* @param symbol Contract symbol
* @param contractURI Contract-level metadata
* @param artist Blueprint artist
*/
struct CreatorBlueprintsInput {
string name;
string symbol;
string contractURI;
address artist;
}
/**
* @dev Emitted when blueprint seed is revealed
* @param randomSeed Revealed seed
*/
event BlueprintSeed(string randomSeed);
/**
* @dev Emitted when NFTs of blueprint are minted
* @param artist Blueprint artist
* @param purchaser Purchaser of NFTs
* @param tokenId NFT minted
* @param newCapacity New capacity of tokens left in blueprint
* @param seedPrefix Seed prefix hash
*/
event BlueprintMinted(
address artist,
address purchaser,
uint128 tokenId,
uint64 newCapacity,
bytes32 seedPrefix
);
/**
* @dev Emitted when blueprint is prepared
* @param artist Blueprint artist
* @param capacity Number of NFTs in blueprint
* @param blueprintMetaData Blueprint metadata uri
* @param baseTokenUri Blueprint's base token uri. Token uris are a result of the base uri concatenated with token id
*/
event BlueprintPrepared(
address artist,
uint64 capacity,
string blueprintMetaData,
string baseTokenUri
);
/**
* @dev Emitted when blueprint sale is started
*/
event SaleStarted();
/**
* @dev Emitted when blueprint sale is paused
*/
event SalePaused();
/**
* @dev Emitted when blueprint sale is unpaused
*/
event SaleUnpaused();
/**
* @dev Emitted when blueprint token uri is updated
* @param newBaseTokenUri New base uri
*/
event BlueprintTokenUriUpdated(string newBaseTokenUri);
/**
* @dev Checks blueprint sale state
*/
modifier isBlueprintPrepared() {
require(
blueprint.saleState != SaleState.not_prepared,
"!prepared"
);
_;
}
/**
* @dev Checks if blueprint sale is ongoing
*/
modifier isSaleOngoing() {
require(_isSaleOngoing(), "!ongoing");
_;
}
/**
* @dev Checks if quantity of NFTs is available for purchase in blueprint
* @param _quantity Quantity of NFTs being checked
*/
modifier isQuantityAvailableForPurchase(
uint32 _quantity
) {
require(
blueprint.capacity >= _quantity,
"quantity >"
);
_;
}
/**
* @dev Checks if sale is still valid, given the sale end timestamp
* @param _saleEndTimestamp Sale end timestamp
*/
modifier isSaleEndTimestampCurrentlyValid(
uint128 _saleEndTimestamp
) {
require(_isSaleEndTimestampCurrentlyValid(_saleEndTimestamp), "ended");
_;
}
/**
* @dev Validates royalty parameters. Allow null-equivalent values for certain use-cases
* @param _royaltyParameters Royalty parameters
*/
modifier validRoyaltyParameters(
RoyaltyParameters calldata _royaltyParameters
) {
require(_royaltyParameters.royaltyCutBPS <= 10000);
_;
}
/**
* @dev Iniitalize the implementation
* @param creatorBlueprintsInput Core parameters for contract initialization
* @param creatorBlueprintsAdmins Administrative accounts
* @param _royaltyParameters Initial royalty settings
* @param extraMinter Additional address to give minter role
*/
function initialize(
CreatorBlueprintsInput calldata creatorBlueprintsInput,
IBlueprintTypes.Admins calldata creatorBlueprintsAdmins,
RoyaltyParameters calldata _royaltyParameters,
address extraMinter
) public initializer validRoyaltyParameters(_royaltyParameters) {
// Intialize parent contracts
ERC721Upgradeable.__ERC721_init(creatorBlueprintsInput.name, creatorBlueprintsInput.symbol);
HasSecondarySaleFees._initialize();
AccessControlUpgradeable.__AccessControl_init();
_setupRole(DEFAULT_ADMIN_ROLE, creatorBlueprintsAdmins.platform);
_setupRole(MINTER_ROLE, creatorBlueprintsAdmins.minter);
if (extraMinter != address(0)) {
_setupRole(MINTER_ROLE, extraMinter);
}
platform = creatorBlueprintsAdmins.platform;
minterAddress = creatorBlueprintsAdmins.minter;
artist = creatorBlueprintsInput.artist;
defaultPlatformPrimaryFeePercentage = 2000; // 20%
asyncSaleFeesRecipient = creatorBlueprintsAdmins.asyncSaleFeesRecipient;
contractURI = creatorBlueprintsInput.contractURI;
royaltyParameters = _royaltyParameters;
operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
operatorFilterRegistry.registerAndSubscribe(address(this), 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
}
/**
* @dev Validates that sale is still ongoing
*/
function _isSaleOngoing()
internal
view
returns (bool)
{
return blueprint.saleState == SaleState.started && _isSaleEndTimestampCurrentlyValid(blueprint.saleEndTimestamp);
}
/**
* @dev Checks if user whitelisted for presale purchase
* @param _whitelistedQuantity Purchaser's requested quantity. Validated against merkle tree
* @param proof Corresponding proof for purchaser in merkle tree
*/
function _isWhitelistedAndPresale(
uint32 _whitelistedQuantity,
bytes32[] calldata proof
)
internal
view
returns (bool)
{
return (_isBlueprintPreparedAndNotStarted() && proof.length != 0 && _verify(_leaf(msg.sender, uint256(_whitelistedQuantity)), blueprint.merkleroot, proof));
}
/**
* @dev Checks if sale is still valid, given the sale end timestamp
* @param _saleEndTimestamp Sale end timestamp
*/
function _isSaleEndTimestampCurrentlyValid(uint128 _saleEndTimestamp)
internal
view
returns (bool)
{
return _saleEndTimestamp > block.timestamp || _saleEndTimestamp == 0;
}
/**
* @dev Checks that blueprint is prepared but sale for it hasn't started
*/
function _isBlueprintPreparedAndNotStarted()
internal
view
returns (bool)
{
return blueprint.saleState == SaleState.not_started;
}
/**
* @dev Checks that the recipients and allocations arrays of royalties are valid
* @param _feeRecipients Fee recipients
* @param _feeBPS Allocations in percentages for fee recipients (basis points)
*/
function feeArrayDataValid(
address[] memory _feeRecipients,
uint32[] memory _feeBPS
) internal pure returns (bool) {
require(
_feeRecipients.length == _feeBPS.length,
"invalid"
);
uint32 totalPercent;
for (uint256 i; i < _feeBPS.length; i++) {
totalPercent = totalPercent + _feeBPS[i];
}
require(totalPercent <= 10000, "bps >");
return true;
}
/**
* @dev Sets values after blueprint preparation
* @param _blueprintMetaData Blueprint metadata uri
*/
function setBlueprintPrepared(
string memory _blueprintMetaData
) internal {
blueprint.saleState = SaleState.not_started;
//assign the erc721 token index to the blueprint
blueprint.erc721TokenIndex = latestErc721TokenIndex;
uint64 _capacity = blueprint.capacity;
latestErc721TokenIndex += _capacity;
emit BlueprintPrepared(
artist,
_capacity,
_blueprintMetaData,
blueprint.baseTokenUri
);
}
/**
* @dev Sets the ERC20 token value of a blueprint
* @param _erc20Token ERC20 token being set
*/
function setErc20Token(address _erc20Token) internal {
if (_erc20Token != address(0)) {
blueprint.ERC20Token = _erc20Token;
}
}
/**
* @dev Sets up most blueprint parameters
* @param _erc20Token ERC20 currency
* @param _baseTokenUri Base token uri for blueprint
* @param _merkleroot Root of merkle tree allowlist
* @param _mintAmountArtist Amount that artist can mint of blueprint
* @param _mintAmountPlatform Amount that platform can mint of blueprint
* @param _maxPurchaseAmount Max amount of NFTs purchasable in one transaction
* @param _saleEndTimestamp When the sale ends
*/
function _setupBlueprint(
address _erc20Token,
string memory _baseTokenUri,
bytes32 _merkleroot,
uint32 _mintAmountArtist,
uint32 _mintAmountPlatform,
uint64 _maxPurchaseAmount,
uint128 _saleEndTimestamp
) internal
isSaleEndTimestampCurrentlyValid(_saleEndTimestamp)
{
setErc20Token(_erc20Token);
blueprint.baseTokenUri = _baseTokenUri;
if (_merkleroot != 0) {
blueprint.merkleroot = _merkleroot;
}
blueprint.mintAmountArtist = _mintAmountArtist;
blueprint.mintAmountPlatform = _mintAmountPlatform;
if (_maxPurchaseAmount != 0) {
blueprint.maxPurchaseAmount = _maxPurchaseAmount;
}
if (_saleEndTimestamp != 0) {
blueprint.saleEndTimestamp = _saleEndTimestamp;
}
}
/**
* @dev Prepare the blueprint (this is the core operation to set up a blueprint)
* @param config Object containing values required to prepare blueprint
* @param _feeRecipientInfo Primary and secondary fees config
*/
function prepareBlueprint(
IBlueprintTypes.BlueprintPreparationConfig calldata config,
IBlueprintTypes.PrimaryFees calldata _feeRecipientInfo
) external
onlyRole(MINTER_ROLE)
{
require(blueprint.saleState == SaleState.not_prepared, "already prepared");
blueprint.capacity = config._capacity;
blueprint.price = config._price;
_setupBlueprint(
config._erc20Token,
config._baseTokenUri,
config._merkleroot,
config._mintAmountArtist,
config._mintAmountPlatform,
config._maxPurchaseAmount,
config._saleEndTimestamp
);
setBlueprintPrepared(config._blueprintMetaData);
setFeeRecipients(_feeRecipientInfo);
}
/**
* @dev Update a blueprint's artist
* @param _newArtist New artist
*/
function updateBlueprintArtist (
address _newArtist
) external onlyRole(MINTER_ROLE) {
artist = _newArtist;
}
/**
* @dev Update a blueprint's merkleroot
* @param _newMerkleroot New merkleroot
*/
function updateBlueprintMerkleroot (
bytes32 _newMerkleroot
) external onlyRole(MINTER_ROLE) {
blueprint.merkleroot = _newMerkleroot;
}
/**
* @dev Update a blueprint's capacity
* @param _newCapacity New capacity
* @param _newLatestErc721TokenIndex Newly adjusted last ERC721 token id
*/
function updateBlueprintCapacity (
uint64 _newCapacity,
uint64 _newLatestErc721TokenIndex
) external onlyRole(MINTER_ROLE) {
require(blueprint.capacity > _newCapacity, "New cap too large");
blueprint.capacity = _newCapacity;
latestErc721TokenIndex = _newLatestErc721TokenIndex;
}
/**
* @dev Set the primary fees config of blueprint
* @param _feeRecipientInfo Fees config
*/
function setFeeRecipients(
IBlueprintTypes.PrimaryFees memory _feeRecipientInfo
) public onlyRole(MINTER_ROLE) {
require(
blueprint.saleState != SaleState.not_prepared,
"never prepared"
);
if (feeArrayDataValid(_feeRecipientInfo.primaryFeeRecipients, _feeRecipientInfo.primaryFeeBPS)) {
blueprint.feeRecipientInfo = _feeRecipientInfo;
}
}
/**
* @dev Begin blueprint's sale
*/
function beginSale()
external
onlyRole(MINTER_ROLE)
isSaleEndTimestampCurrentlyValid(blueprint.saleEndTimestamp)
{
require(
blueprint.saleState == SaleState.not_started,
"sale started or not prepared"
);
blueprint.saleState = SaleState.started;
emit SaleStarted();
}
/**
* @dev Pause blueprint's sale
*/
function pauseSale()
external
onlyRole(MINTER_ROLE)
isSaleOngoing()
{
blueprint.saleState = SaleState.paused;
emit SalePaused();
}
/**
* @dev Unpause blueprint's sale
*/
function unpauseSale() external onlyRole(MINTER_ROLE) isSaleEndTimestampCurrentlyValid(blueprint.saleEndTimestamp) {
require(
blueprint.saleState == SaleState.paused,
"!paused"
);
blueprint.saleState = SaleState.started;
emit SaleUnpaused();
}
/**
* @dev Purchase NFTs of blueprint to a recipient address
* @param purchaseQuantity How many NFTs to purchase
* @param whitelistedQuantity How many NFTS are whitelisted for the blueprint
* @param tokenAmount Payment amount
* @param proof Merkle tree proof
* @param nftRecipient Recipient of minted NFTs
*/
function purchaseBlueprintsTo(
uint32 purchaseQuantity,
uint32 whitelistedQuantity,
uint256 tokenAmount,
bytes32[] calldata proof,
address nftRecipient
)
external
payable
nonReentrant
isQuantityAvailableForPurchase(purchaseQuantity)
{
if (_isWhitelistedAndPresale(whitelistedQuantity, proof)) {
require(whitelistedPurchases[msg.sender] + purchaseQuantity <= whitelistedQuantity, "> whitelisted amount");
whitelistedPurchases[msg.sender] += purchaseQuantity;
} else {
require(_isSaleOngoing(), "unavailable");
}
require(
blueprint.maxPurchaseAmount == 0 ||
purchaseQuantity <= blueprint.maxPurchaseAmount,
"cannot buy > maxPurchaseAmount in one tx"
);
_confirmPaymentAmountAndSettleSale(
purchaseQuantity,
tokenAmount,
artist
);
_mintQuantity(purchaseQuantity, nftRecipient);
}
/**
* @dev Purchase NFTs of blueprint to the sender
* @param purchaseQuantity How many NFTs to purchase
* @param whitelistedQuantity How many NFTS are whitelisted for the blueprint
* @param tokenAmount Payment amount
* @param proof Merkle tree proof
*/
function purchaseBlueprints(
uint32 purchaseQuantity,
uint32 whitelistedQuantity,
uint256 tokenAmount,
bytes32[] calldata proof
)
external
payable
nonReentrant
isQuantityAvailableForPurchase(purchaseQuantity)
{
if (_isWhitelistedAndPresale(whitelistedQuantity, proof)) {
require(whitelistedPurchases[msg.sender] + purchaseQuantity <= whitelistedQuantity, "> whitelisted amount");
whitelistedPurchases[msg.sender] += purchaseQuantity;
} else {
require(_isSaleOngoing(), "unavailable");
}
require(
blueprint.maxPurchaseAmount == 0 ||
purchaseQuantity <= blueprint.maxPurchaseAmount,
"cannot buy > maxPurchaseAmount in one tx"
);
_confirmPaymentAmountAndSettleSale(
purchaseQuantity,
tokenAmount,
artist
);
_mintQuantity(purchaseQuantity, msg.sender);
}
/**
* @dev Lets the artist mint NFTs of the blueprint
* @param quantity How many NFTs to mint
*/
function artistMint(
uint32 quantity
)
external
nonReentrant
{
address _artist = artist; // cache
require(
_isBlueprintPreparedAndNotStarted() || _isSaleOngoing(),
"not pre/public sale"
);
require(
minterAddress == msg.sender ||
_artist == msg.sender,
"unauthorized"
);
if (minterAddress == msg.sender) {
require(
quantity <= blueprint.mintAmountPlatform,
"quantity >"
);
blueprint.mintAmountPlatform -= quantity;
} else if (_artist == msg.sender) {
require(
quantity <= blueprint.mintAmountArtist,
"quantity >"
);
blueprint.mintAmountArtist -= quantity;
}
_mintQuantity(quantity, msg.sender);
}
/**
* @dev Mint a quantity of NFTs of blueprint to a recipient
* @param _quantity Quantity to mint
* @param _nftRecipient Recipient of minted NFTs
*/
function _mintQuantity(uint32 _quantity, address _nftRecipient) private {
uint128 newTokenId = blueprint.erc721TokenIndex;
uint64 newCap = blueprint.capacity;
for (uint16 i; i < _quantity; i++) {
require(newCap > 0, "quantity > cap");
_mint(_nftRecipient, newTokenId + i);
bytes32 prefixHash = keccak256(
abi.encodePacked(
block.number,
block.timestamp,
block.coinbase,
newCap
)
);
emit BlueprintMinted(
artist,
_nftRecipient,
newTokenId + i,
newCap,
prefixHash
);
--newCap;
}
blueprint.erc721TokenIndex += _quantity;
blueprint.capacity = newCap;
}
/**
* @dev Pay for minting NFTs
* @param _quantity Quantity of NFTs to purchase
* @param _tokenAmount Payment amount provided
* @param _artist Artist of blueprint
*/
function _confirmPaymentAmountAndSettleSale(
uint32 _quantity,
uint256 _tokenAmount,
address _artist
) internal {
address _erc20Token = blueprint.ERC20Token;
uint128 _price = blueprint.price;
if (_erc20Token == address(0)) {
require(_tokenAmount == 0, "tokenAmount != 0");
require(
msg.value == _quantity * _price,
"$ != expected"
);
_payFeesAndArtist(_erc20Token, msg.value, _artist);
} else {
require(msg.value == 0, "eth value != 0");
require(
_tokenAmount == _quantity * _price,
"$ != expected"
);
IERC20(_erc20Token).transferFrom(
msg.sender,
address(this),
_tokenAmount
);
_payFeesAndArtist(_erc20Token, _tokenAmount, _artist);
}
}
////////////////////////////////////
////// MERKLEROOT FUNCTIONS ////////
////////////////////////////////////
/**
* Create a merkle tree with address: quantity pairs as the leaves.
* The msg.sender will be verified if it has a corresponding quantity value in the merkletree
*/
/**
* @dev Create a merkle tree with address: quantity pairs as the leaves.
* The msg.sender will be verified if it has a corresponding quantity value in the merkletree
* @param account Minting account being verified
* @param quantity Quantity to mint, being verified
*/
function _leaf(address account, uint256 quantity)
internal
pure
returns (bytes32)
{
return keccak256(abi.encodePacked(account, quantity));
}
/**
* @dev Verify a leaf's inclusion in a merkle tree with its root and corresponding proof
* @param leaf Leaf to verify
* @param merkleroot Merkle tree's root
* @param proof Corresponding proof for leaf
*/
function _verify(
bytes32 leaf,
bytes32 merkleroot,
bytes32[] memory proof
) internal pure returns (bool) {
return MerkleProof.verify(proof, merkleroot, leaf);
}
////////////////////////////
/// ONLY ADMIN functions ///
////////////////////////////
/**
* @dev Update blueprint's token uri
* @param newBaseTokenUri New base token uri to update to
*/
function updateBlueprintTokenUri(
string memory newBaseTokenUri
) external onlyRole(MINTER_ROLE) isBlueprintPrepared() {
require(
!blueprint.tokenUriLocked,
"URI locked"
);
blueprint.baseTokenUri = newBaseTokenUri;
emit BlueprintTokenUriUpdated(newBaseTokenUri);
}
/**
* @dev Lock blueprint's token uri (from changing)
*/
function lockBlueprintTokenUri()
external
onlyRole(DEFAULT_ADMIN_ROLE)
isBlueprintPrepared()
{
require(
!blueprint.tokenUriLocked,
"URI locked"
);
blueprint.tokenUriLocked = true;
}
/**
* @dev Return token's uri
* @param tokenId ID of token to return uri for
* @return Token uri, constructed by taking base uri of blueprint, and concatenating token id
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
require(
_exists(tokenId),
"URI query for nonexistent token"
);
string memory baseURI = blueprint.baseTokenUri;
return
bytes(baseURI).length > 0
? string(
abi.encodePacked(
baseURI,
"/",
tokenId.toString(),
"/",
"token.json"
)
)
: "";
}
/**
* @dev Reveal blueprint's seed by emitting public event
* @param randomSeed Revealed seed
*/
function revealBlueprintSeed(string memory randomSeed)
external
onlyRole(MINTER_ROLE)
isBlueprintPrepared()
{
emit BlueprintSeed(randomSeed);
}
/**
* @dev Set the contract-wide recipient of primary sale feess
* @param _asyncSaleFeesRecipient New async sale fees recipient
*/
function setAsyncFeeRecipient(address _asyncSaleFeesRecipient)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
asyncSaleFeesRecipient = _asyncSaleFeesRecipient;
}
/**
* @dev Change the default percentage of primary sales sent to platform
* @param _basisPoints New default platform primary fee percentage (in basis points)
*/
function changeDefaultPlatformPrimaryFeePercentage(uint32 _basisPoints)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
require(_basisPoints <= 10000);
defaultPlatformPrimaryFeePercentage = _basisPoints;
}
/**
* @dev Update royalty config
* @param _royaltyParameters New royalty parameters
*/
function updateRoyaltyParameters(RoyaltyParameters calldata _royaltyParameters)
external
onlyRole(DEFAULT_ADMIN_ROLE)
validRoyaltyParameters(_royaltyParameters)
{
royaltyParameters = _royaltyParameters;
}
/**
* @dev Update contract-wide platform address, and DEFAULT_ADMIN role ownership
* @param _platform New platform address
*/
function updatePlatformAddress(address _platform)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
grantRole(DEFAULT_ADMIN_ROLE, _platform);
revokeRole(DEFAULT_ADMIN_ROLE, platform);
platform = _platform;
}
/**
* @dev Update contract-wide minter address, and MINTER_ROLE role ownership
* @param newMinterAddress New minter address
*/
function updateMinterAddress(address newMinterAddress)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
grantRole(MINTER_ROLE, newMinterAddress);
revokeRole(MINTER_ROLE, minterAddress);
minterAddress = newMinterAddress;
}
////////////////////////////////////
/// Secondary Fees implementation //
////////////////////////////////////
/**
* @dev Pay primary fees owed to primary fee recipients
* @param _erc20Token ERC20 token used for payment (if used)
* @param _amount Payment amount
* @param _artist Artist being paid
*/
function _payFeesAndArtist(
address _erc20Token,
uint256 _amount,
address _artist
) internal {
address[] memory _primaryFeeRecipients = getPrimaryFeeRecipients();
uint32[] memory _primaryFeeBPS = getPrimaryFeeBps();
uint256 feesPaid;
for (uint256 i; i < _primaryFeeRecipients.length; i++) {
uint256 fee = (_amount * _primaryFeeBPS[i])/10000;
feesPaid = feesPaid + fee;
_payout(_primaryFeeRecipients[i], _erc20Token, fee);
}
if (_amount - feesPaid > 0) {
_payout(_artist, _erc20Token, (_amount - feesPaid));
}
}
/**
* @dev Simple payment function to pay an amount of currency to a recipient
* @param _recipient Recipient of payment
* @param _erc20Token ERC20 token used for payment (if used)
* @param _amount Payment amount
*/
function _payout(
address _recipient,
address _erc20Token,
uint256 _amount
) internal {
if (_erc20Token != address(0)) {
IERC20(_erc20Token).transfer(_recipient, _amount);
} else {
// attempt to send the funds to the recipient
(bool success, ) = payable(_recipient).call{
value: _amount,
gas: 20000
}("");
// if it failed, update their credit balance so they can pull it later
if (!success) {
failedTransferCredits[_recipient] =
failedTransferCredits[_recipient] +
_amount;
}
}
}
/**
* @dev When a native gas token payment fails, credits are stored so that the would-be recipient can withdraw them later.
* Withdraw failed credits for a recipient
* @param recipient Recipient owed some amount of native gas token
*/
function withdrawAllFailedCredits(address payable recipient) external {
uint256 amount = failedTransferCredits[msg.sender];
require(amount != 0, "no credits to withdraw");
failedTransferCredits[msg.sender] = 0;
(bool successfulWithdraw, ) = recipient.call{value: amount, gas: 20000}(
""
);
require(successfulWithdraw, "withdraw failed");
}
/**
* @dev Get primary fee recipients of blueprint
*/
function getPrimaryFeeRecipients()
public
view
returns (address[] memory)
{
if (blueprint.feeRecipientInfo.primaryFeeRecipients.length == 0) {
address[] memory primaryFeeRecipients = new address[](1);
primaryFeeRecipients[0] = (asyncSaleFeesRecipient);
return primaryFeeRecipients;
} else {
return blueprint.feeRecipientInfo.primaryFeeRecipients;
}
}
/**
* @dev Get primary fee bps (allocations) of blueprint
*/
function getPrimaryFeeBps()
public
view
returns (uint32[] memory)
{
if (blueprint.feeRecipientInfo.primaryFeeBPS.length == 0) {
uint32[] memory primaryFeeBPS = new uint32[](1);
primaryFeeBPS[0] = defaultPlatformPrimaryFeePercentage;
return primaryFeeBPS;
} else {
return blueprint.feeRecipientInfo.primaryFeeBPS;
}
}
/**
* @dev Get secondary fee recipients of a token
* @param tokenId Token ID
*/
function getFeeRecipients(uint256 tokenId)
public
view
override
returns (address[] memory)
{
address[] memory feeRecipients = new address[](1);
feeRecipients[0] = royaltyParameters.split;
return feeRecipients;
}
/**
* @dev Get secondary fee bps (allocations) of a token
* @param tokenId Token ID
*/
function getFeeBps(uint256 tokenId)
public
view
override
returns (uint32[] memory)
{
uint32[] memory feeBps = new uint32[](1);
feeBps[0] = royaltyParameters.royaltyCutBPS;
return feeBps;
}
/**
* @dev Support ERC-2981
* @param _tokenId ID of token to return royalty for
* @param _salePrice Price that NFT was sold at
* @return receiver Royalty split
* @return royaltyAmount Amount to send to royalty split
*/
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view returns (
address receiver,
uint256 royaltyAmount
) {
receiver = royaltyParameters.split;
royaltyAmount = _salePrice * royaltyParameters.royaltyCutBPS / 10000;
}
/**
* @dev Used for interoperability purposes
* @return Returns platform address as owner of contract
*/
function owner() public view virtual returns (address) {
return platform;
}
////////////////////////////////////
/// Required function overide //////
////////////////////////////////////
/**
* @dev Override isApprovedForAll to also let the DEFAULT_ADMIN_ROLE move tokens
* @param account Account holding tokens being moved
* @param operator Operator moving tokens
*/
function isApprovedForAll(address account, address operator)
public
view
override
returns (bool)
{
return
super.isApprovedForAll(account, operator) ||
hasRole(DEFAULT_ADMIN_ROLE, operator);
}
/**
* @dev ERC165 - Validate that the contract supports a interface
* @param interfaceId ID of interface being validated
* @return Returns true if contract supports interface
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(
ERC721Upgradeable,
ERC165StorageUpgradeable,
AccessControlEnumerableUpgradeable
)
returns (bool)
{
return
interfaceId == type(HasSecondarySaleFees).interfaceId ||
ERC721Upgradeable.supportsInterface(interfaceId) ||
ERC165StorageUpgradeable.supportsInterface(interfaceId) ||
AccessControlEnumerableUpgradeable.supportsInterface(interfaceId);
}
/////////////////////////////////////////////////
/// Required for OpenSea Operator Registry //////
/////////////////////////////////////////////////
// Custom Error Type For Operator Registry Methods
error OperatorNotAllowed(address operator);
/**
* @dev Restrict operators who are allowed to transfer these tokens
*/
modifier onlyAllowedOperator(address from) {
if (from != msg.sender) {
_checkFilterOperator(msg.sender);
}
_;
}
/**
* @dev Restrict operators who are allowed to approve transfer delegates
*/
modifier onlyAllowedOperatorApproval(address operator) {
_checkFilterOperator(operator);
_;
}
/**
* @notice Register this contract with the OpenSea operator registry. Subscribe to OpenSea's operator blacklist.
*/
function registerWithOpenSeaOperatorRegistry() public {
require(
owner() == msg.sender || artist == msg.sender,
"unauthorized"
);
IOperatorFilterRegistry registry = operatorFilterRegistry;
require(address(registry) != address(0), "attempt register to zero addr");
registry.registerAndSubscribe(address(this), 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
}
/**
* @notice Update the address that the contract will make OperatorFilter checks against. When set to the zero
* address, checks will be bypassed.
*/
function updateOperatorFilterRegistryAddress(address newRegistry) public {
require(
owner() == msg.sender || artist == msg.sender,
"unauthorized"
);
operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
}
/**
* @notice Update the address that the contract will make OperatorFilter checks against. Also register this contract with that registry.
*/
function updateOperatorFilterAndRegister(address newRegistry) public {
updateOperatorFilterRegistryAddress(newRegistry);
registerWithOpenSeaOperatorRegistry();
}
/**
* @dev Check if operator can perform an action
*/
function _checkFilterOperator(address operator) internal view {
IOperatorFilterRegistry registry = operatorFilterRegistry;
// Check registry code length to facilitate testing in environments without a deployed registry.
if (address(registry) != address(0) && address(registry).code.length > 0) {
if (!registry.isOperatorAllowed(address(this), operator)) {
revert OperatorNotAllowed(operator);
}
}
}
// Override 721 Methods to restrict non-royalty enforcing operators
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
super.setApprovalForAll(operator, approved);
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
super.approve(operator, tokenId);
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
super.transferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
super.safeTransferFrom(from, to, tokenId, data);
}
}
//SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165StorageUpgradeable.sol";
abstract contract HasSecondarySaleFees is ERC165StorageUpgradeable {
event SecondarySaleFees(
uint256 tokenId,
address[] recipients,
uint256[] bps
);
/*
* bytes4(keccak256('getFeeBps(uint256)')) == 0x0ebd4c7f
* bytes4(keccak256('getFeeRecipients(uint256)')) == 0xb9c4d9fb
*
* => 0x0ebd4c7f ^ 0xb9c4d9fb == 0xb7799584
*/
bytes4 private constant _INTERFACE_ID_FEES = 0xb7799584;
function _initialize() public initializer {
_registerInterface(_INTERFACE_ID_FEES);
}
function getFeeRecipients(uint256 id)
public
view
virtual
returns (address[] memory);
function getFeeBps(uint256 id)
public
view
virtual
returns (uint32[] memory);
}
//SPDX-License-Identifier: Unlicense
pragma solidity 0.8.4;
/**
* @dev Interface used to share common types between AsyncArt Blueprints contracts
* @author Ohimire Labs
*/
interface IBlueprintTypes {
/**
* @dev Core administrative accounts
* @param platform Platform, holder of DEFAULT_ADMIN role
* @param minter Minter, holder of MINTER_ROLE
* @param asyncSaleFeesRecipient Recipient of primary sale fees going to platform
*/
struct Admins {
address platform;
address minter;
address asyncSaleFeesRecipient;
}
/**
* @dev Object passed in when preparing blueprint
* @param _capacity Number of NFTs in Blueprint
* @param _price Price per NFT in Blueprint
* @param _erc20Token Address of ERC20 currency required to buy NFTs, can be zero address if expected currency is native gas token
* @param _blueprintMetaData Blueprint metadata uri
* @param _baseTokenUri Base URI for token, resultant uri for each token is base uri concatenated with token id
* @param _merkleroot Root of Merkle tree holding whitelisted accounts
* @param _mintAmountArtist Amount of NFTs of Blueprint mintable by artist
* @param _mintAmountPlatform Amount of NFTs of Blueprint mintable by platform
* @param _maxPurchaseAmount Max number of NFTs purchasable in a single transaction
* @param _saleEndTimestamp Timestamp when the sale ends
*/
struct BlueprintPreparationConfig {
uint64 _capacity;
uint128 _price;
address _erc20Token;
string _blueprintMetaData;
string _baseTokenUri;
bytes32 _merkleroot;
uint32 _mintAmountArtist;
uint32 _mintAmountPlatform;
uint64 _maxPurchaseAmount;
uint128 _saleEndTimestamp;
}
/**
* @dev Object holding primary fee data
* @param primaryFeeBPS Primary fee percentage allocations, in basis points
* @param primaryFeeRecipients Primary fee recipients
*/
struct PrimaryFees {
uint32[] primaryFeeBPS;
address[] primaryFeeRecipients;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC721Upgradeable.sol";
import "./IERC721ReceiverUpgradeable.sol";
import "./extensions/IERC721MetadataUpgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../utils/StringsUpgradeable.sol";
import "../../utils/introspection/ERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {
using AddressUpgradeable for address;
using StringsUpgradeable for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
function __ERC721_init(string memory name_, string memory symbol_) internal initializer {
__Context_init_unchained();
__ERC165_init_unchained();
__ERC721_init_unchained(name_, symbol_);
}
function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return
interfaceId == type(IERC721Upgradeable).interfaceId ||
interfaceId == type(IERC721MetadataUpgradeable).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
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, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return "";
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721Upgradeable.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @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.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @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 (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721Upgradeable.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721Upgradeable.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721ReceiverUpgradeable.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* 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, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
uint256[44] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IAccessControlEnumerableUpgradeable.sol";
import "./AccessControlUpgradeable.sol";
import "../utils/structs/EnumerableSetUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev Extension of {AccessControl} that allows enumerating the members of each role.
*/
abstract contract AccessControlEnumerableUpgradeable is Initializable, IAccessControlEnumerableUpgradeable, AccessControlUpgradeable {
function __AccessControlEnumerable_init() internal initializer {
__Context_init_unchained();
__ERC165_init_unchained();
__AccessControl_init_unchained();
__AccessControlEnumerable_init_unchained();
}
function __AccessControlEnumerable_init_unchained() internal initializer {
}
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
mapping(bytes32 => EnumerableSetUpgradeable.AddressSet) private _roleMembers;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlEnumerableUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns one of the accounts that have `role`. `index` must be a
* value between 0 and {getRoleMemberCount}, non-inclusive.
*
* Role bearers are not sorted in any particular way, and their ordering may
* change at any point.
*
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
* you perform all queries on the same block. See the following
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
* for more information.
*/
function getRoleMember(bytes32 role, uint256 index) public view override returns (address) {
return _roleMembers[role].at(index);
}
/**
* @dev Returns the number of accounts that have `role`. Can be used
* together with {getRoleMember} to enumerate all bearers of a role.
*/
function getRoleMemberCount(bytes32 role) public view override returns (uint256) {
return _roleMembers[role].length();
}
/**
* @dev Overload {grantRole} to track enumerable memberships
*/
function grantRole(bytes32 role, address account) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
super.grantRole(role, account);
_roleMembers[role].add(account);
}
/**
* @dev Overload {revokeRole} to track enumerable memberships
*/
function revokeRole(bytes32 role, address account) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
super.revokeRole(role, account);
_roleMembers[role].remove(account);
}
/**
* @dev Overload {renounceRole} to track enumerable memberships
*/
function renounceRole(bytes32 role, address account) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
super.renounceRole(role, account);
_roleMembers[role].remove(account);
}
/**
* @dev Overload {_setupRole} to track enumerable memberships
*/
function _setupRole(bytes32 role, address account) internal virtual override {
super._setupRole(role, account);
_roleMembers[role].add(account);
}
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/MerkleProof.sol)
pragma solidity ^0.8.0;
/**
* @dev These functions deal with verification of Merkle Tree proofs.
*
* The proofs can be generated using the JavaScript library
* https://github.com/miguelmota/merkletreejs[merkletreejs].
* Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
*
* See `test/utils/cryptography/MerkleProof.test.js` for some examples.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
/**
* @dev Calldata version of {verify}
*
* _Available since v4.7._
*/
function verifyCalldata(
bytes32[] calldata proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProofCalldata(proof, leaf) == root;
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Calldata version of {processProof}
*
* _Available since v4.7._
*/
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Returns true if the `leaves` can be proved to be a part of a Merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* _Available since v4.7._
*/
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
/**
* @dev Calldata version of {multiProofVerify}
*
* _Available since v4.7._
*/
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves) == root;
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and the sibling nodes in `proof`,
* consuming from one or the other at each step according to the instructions given by
* `proofFlags`.
*
* _Available since v4.7._
*/
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
// This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the merkle tree.
uint256 leavesLen = leaves.length;
uint256 totalHashes = proofFlags.length;
// Check proof validity.
require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
return hashes[totalHashes - 1];
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
/**
* @dev Calldata version of {processMultiProof}
*
* _Available since v4.7._
*/
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
// This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the merkle tree.
uint256 leavesLen = leaves.length;
uint256 totalHashes = proofFlags.length;
// Check proof validity.
require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
return hashes[totalHashes - 1];
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
pragma solidity ^0.8.0;
/**
* @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 ReentrancyGuard {
// 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;
constructor() {
_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;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev Storage based implementation of the {IERC165} interface.
*
* Contracts may inherit from this and call {_registerInterface} to declare
* their support of an interface.
*/
abstract contract ERC165StorageUpgradeable is Initializable, ERC165Upgradeable {
function __ERC165Storage_init() internal initializer {
__ERC165_init_unchained();
__ERC165Storage_init_unchained();
}
function __ERC165Storage_init_unchained() internal initializer {
}
/**
* @dev Mapping of interface ids to whether or not it's supported.
*/
mapping(bytes4 => bool) private _supportedInterfaces;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];
}
/**
* @dev Registers the contract as an implementer of the interface defined by
* `interfaceId`. Support of the actual ERC165 interface is automatic and
* registering its interface id is not required.
*
* See {IERC165-supportsInterface}.
*
* Requirements:
*
* - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
*/
function _registerInterface(bytes4 interfaceId) internal virtual {
require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
_supportedInterfaces[interfaceId] = true;
}
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal initializer {
__ERC165_init_unchained();
}
function __ERC165_init_unchained() internal initializer {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @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 a proxied contract can't have 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.
*
* 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.
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
*/
bool private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Modifier to protect an initializer function from being invoked twice.
*/
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @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}.
*/
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
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721Upgradeable is IERC165Upgradeable {
/**
* @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
) external;
/**
* @dev Transfers `tokenId` token 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;
/**
* @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;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @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 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);
/**
* @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 calldata data
) external;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721ReceiverUpgradeable {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../IERC721Upgradeable.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721MetadataUpgradeable is IERC721Upgradeable {
/**
* @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.0;
/**
* @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
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 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
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// SPDX-License-Identifier: MIT
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 initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
library StringsUpgradeable {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @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);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IAccessControlUpgradeable.sol";
/**
* @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
*/
interface IAccessControlEnumerableUpgradeable is IAccessControlUpgradeable {
/**
* @dev Returns one of the accounts that have `role`. `index` must be a
* value between 0 and {getRoleMemberCount}, non-inclusive.
*
* Role bearers are not sorted in any particular way, and their ordering may
* change at any point.
*
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
* you perform all queries on the same block. See the following
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
* for more information.
*/
function getRoleMember(bytes32 role, uint256 index) external view returns (address);
/**
* @dev Returns the number of accounts that have `role`. Can be used
* together with {getRoleMember} to enumerate all bearers of a role.
*/
function getRoleMemberCount(bytes32 role) external view returns (uint256);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IAccessControlUpgradeable.sol";
import "../utils/ContextUpgradeable.sol";
import "../utils/StringsUpgradeable.sol";
import "../utils/introspection/ERC165Upgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms. This is a lightweight version that doesn't allow enumerating role
* members except through off-chain means by accessing the contract event logs. Some
* applications may benefit from on-chain enumerability, for those cases see
* {AccessControlEnumerable}.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it.
*/
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {
function __AccessControl_init() internal initializer {
__Context_init_unchained();
__ERC165_init_unchained();
__AccessControl_init_unchained();
}
function __AccessControl_init_unchained() internal initializer {
}
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with a standardized message including the required role.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*
* _Available since v4.1._
*/
modifier onlyRole(bytes32 role) {
_checkRole(role, _msgSender());
_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view override returns (bool) {
return _roles[role].members[account];
}
/**
* @dev Revert with a standard message if `account` is missing `role`.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*/
function _checkRole(bytes32 role, address account) internal view {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
StringsUpgradeable.toHexString(uint160(account), 20),
" is missing role ",
StringsUpgradeable.toHexString(uint256(role), 32)
)
)
);
}
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) private {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
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.
*/
library EnumerableSetUpgradeable {
// 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;
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;
assembly {
result := store
}
return result;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControlUpgradeable {
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*
* _Available since v3.1._
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {AccessControl-_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) external;
}
