Warning! Contract bytecode has been changed and doesn't match the verified one. Therefore, interaction with this smart contract may be risky.
- Contract name:
- ConfigurableGuildRewardNFT
- Optimization enabled
- true
- Compiler version
- v0.8.19+commit.7dd6d404
- Optimization runs
- 200
- EVM Version
- default
- Verified at
- 2025-06-19T17:04:43.077226Z
contracts/ConfigurableGuildRewardNFT.sol
//SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import { IConfigurableGuildRewardNFT } from "./interfaces/IConfigurableGuildRewardNFT.sol";
import { IGuildRewardNFTFactory } from "./interfaces/IGuildRewardNFTFactory.sol";
import { ITreasuryManager } from "./interfaces/ITreasuryManager.sol";
import { LibTransfer } from "./lib/LibTransfer.sol";
import { OptionallySoulboundERC721 } from "./token/OptionallySoulboundERC721.sol";
import { TreasuryManager } from "./utils/TreasuryManager.sol";
import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { ECDSAUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";
import { MulticallUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/MulticallUpgradeable.sol";
import { StringsUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
/// @title An NFT distributed as a reward for Guild.xyz users.
contract ConfigurableGuildRewardNFT is
IConfigurableGuildRewardNFT,
Initializable,
OwnableUpgradeable,
OptionallySoulboundERC721,
TreasuryManager,
MulticallUpgradeable
{
using ECDSAUpgradeable for bytes32;
using LibTransfer for address payable;
using StringsUpgradeable for address;
using StringsUpgradeable for uint256;
uint256 public constant SIGNATURE_VALIDITY = 1 hours;
address public factoryProxy;
uint256 public maxSupply;
uint256 public mintableAmountPerUser;
/// @notice The cid for tokenURI.
string internal cid;
/// @notice The number of claimed tokens by userIds.
mapping(uint256 userId => uint256 claimed) internal claimedTokens;
function initialize(
IGuildRewardNFTFactory.ConfigurableNFTConfig memory nftConfig,
address factoryProxyAddress
) public initializer {
cid = nftConfig.cid;
maxSupply = nftConfig.maxSupply;
mintableAmountPerUser = nftConfig.mintableAmountPerUser;
factoryProxy = factoryProxyAddress;
__OptionallySoulboundERC721_init(nftConfig.name, nftConfig.symbol, nftConfig.soulbound);
__TreasuryManager_init(nftConfig.treasury, nftConfig.tokenFee);
_transferOwnership(nftConfig.tokenOwner);
}
function claim(
uint256 amount,
address receiver,
uint256 userId,
uint256 signedAt,
bytes calldata signature
) external payable {
if (signedAt < block.timestamp - SIGNATURE_VALIDITY) revert ExpiredSignature();
uint256 mintableAmount = mintableAmountPerUser;
if (
mintableAmount > 0 &&
(amount > mintableAmount - balanceOf(receiver) || amount > mintableAmount - claimedTokens[userId])
) revert AlreadyClaimed();
if (!isValidSignature(amount, signedAt, receiver, userId, signature)) revert IncorrectSignature();
(uint256 guildFee, address payable guildTreasury) = ITreasuryManager(factoryProxy).getFeeData();
claimedTokens[userId] += amount;
uint256 firstTokenId = totalSupply();
uint256 lastTokenId = firstTokenId + amount - 1;
uint256 tokenIdCap = maxSupply;
if (tokenIdCap > 0 && lastTokenId >= tokenIdCap) revert MaxSupplyReached(tokenIdCap);
for (uint256 tokenId = firstTokenId; tokenId <= lastTokenId; ) {
_safeMint(receiver, tokenId);
if (soulbound) emit Locked(tokenId);
else emit Unlocked(tokenId);
emit Claimed(receiver, tokenId);
unchecked {
++tokenId;
}
}
// Fee collection
uint256 guildAmount = amount * guildFee;
uint256 ownerAmount = amount * fee;
if (msg.value == guildAmount + ownerAmount) {
guildTreasury.sendEther(guildAmount);
treasury.sendEther(ownerAmount);
} else revert IncorrectFee(msg.value, guildAmount + ownerAmount);
}
function burn(uint256[] calldata tokenIds, uint256 userId, uint256 signedAt, bytes calldata signature) external {
if (signedAt < block.timestamp - SIGNATURE_VALIDITY) revert ExpiredSignature();
uint256 amount = tokenIds.length;
if (!isValidSignature(amount, signedAt, msg.sender, userId, signature)) revert IncorrectSignature();
for (uint256 i; i < amount; ) {
uint256 tokenId = tokenIds[i];
if (msg.sender != ownerOf(tokenId)) revert IncorrectSender();
_burn(tokenId);
unchecked {
++i;
}
}
claimedTokens[userId] -= amount;
}
function setLocked(bool newLocked) external onlyOwner {
soulbound = newLocked;
if (newLocked) emit Locked(0);
else emit Unlocked(0);
}
function setMaxSupply(uint256 newMaxSupply) external onlyOwner {
maxSupply = newMaxSupply;
emit MaxSupplyChanged(newMaxSupply);
}
function setMintableAmountPerUser(uint256 newAmount) external onlyOwner {
mintableAmountPerUser = newAmount;
emit MintableAmountPerUserChanged(newAmount);
}
function updateTokenURI(string calldata newCid) external onlyOwner {
cid = newCid;
emit MetadataUpdate();
}
function balanceOf(uint256 userId) external view returns (uint256 amount) {
return claimedTokens[userId];
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
if (!_exists(tokenId)) revert NonExistentToken(tokenId);
bytes memory cidBytes = bytes(cid);
if (
cidBytes.length >= 4 && cidBytes[0] == "h" && cidBytes[1] == "t" && cidBytes[2] == "t" && cidBytes[3] == "p"
) {
return
string.concat(
cid,
"/",
address(this).toHexString(),
"/",
_ownerOf(tokenId).toHexString(),
"/",
tokenId.toString()
);
}
return string.concat("ipfs://", cid);
}
/// @notice Checks the validity of the signature for the given params.
function isValidSignature(
uint256 amount,
uint256 signedAt,
address receiver,
uint256 userId,
bytes calldata signature
) internal view returns (bool) {
if (signature.length != 65) revert IncorrectSignature();
bytes32 message = keccak256(abi.encode(amount, signedAt, receiver, userId, block.chainid, address(this)))
.toEthSignedMessageHash();
return message.recover(signature) == IGuildRewardNFTFactory(factoryProxy).validSigner();
}
}
@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
* constructor.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: setting the version to 255 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized != type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/ERC721.sol)
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 {Initializable} from "../../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 onlyInitializing {
__ERC721_init_unchained(name_, symbol_);
}
function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_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: address zero is not a valid owner");
return _balances[owner];
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _ownerOf(tokenId);
require(owner != address(0), "ERC721: invalid token ID");
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) {
_requireMinted(tokenId);
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 overridden 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 token owner or approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_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: caller is not token owner or 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: caller is not token owner or 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 the owner of the `tokenId`. Does NOT revert if token doesn't exist
*/
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
/**
* @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 _ownerOf(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) {
address owner = ERC721Upgradeable.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == 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, 1);
// Check that tokenId was not minted by `_beforeTokenTransfer` hook
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
// Will not overflow unless all 2**256 token ids are minted to the same owner.
// Given that tokens are minted one by one, it is impossible in practice that
// this ever happens. Might change if we allow batch minting.
// The ERC fails to describe this case.
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId, 1);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
* This is an internal function that does not check if the sender is authorized to operate on the token.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721Upgradeable.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
// Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
owner = ERC721Upgradeable.ownerOf(tokenId);
// Clear approvals
delete _tokenApprovals[tokenId];
unchecked {
// Cannot overflow, as that would require more tokens to be burned/transferred
// out than the owner initially received through minting and transferring in.
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId, 1);
}
/**
* @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 from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId, 1);
// Check that tokenId was not transferred by `_beforeTokenTransfer` hook
require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
// Clear approvals from the previous owner
delete _tokenApprovals[tokenId];
unchecked {
// `_balances[from]` cannot overflow for the same reason as described in `_burn`:
// `from`'s balance is the number of token held, which is at least one before the current
// transfer.
// `_balances[to]` could overflow in the conditions described in `_mint`. That would require
// all 2**256 token ids to be minted, which in practice is impossible.
_balances[from] -= 1;
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId, 1);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits an {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
/**
* @dev Reverts if the `tokenId` has not been minted yet.
*/
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
/**
* @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 {
/// @solidity memory-safe-assembly
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
* - When `from` is zero, the tokens will be minted for `to`.
* - When `to` is zero, ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
/**
* @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
* - When `from` is zero, the tokens were minted for `to`.
* - When `to` is zero, ``from``'s tokens were burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
/**
* @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
*
* WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant
* being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such
* that `ownerOf(tokenId)` is `a`.
*/
// solhint-disable-next-line func-name-mixedcase
function __unsafe_increaseBalance(address account, uint256 amount) internal {
_balances[account] += amount;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[44] private __gap;
}
@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)
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 `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)
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`.
*
* 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;
/**
* @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 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
* or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
* understand this adds an external call which potentially creates a reentrancy vulnerability.
*
* 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 Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)
pragma solidity ^0.8.0;
import "../ERC721Upgradeable.sol";
import "./IERC721EnumerableUpgradeable.sol";
import {Initializable} from "../../../proxy/utils/Initializable.sol";
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721EnumerableUpgradeable is Initializable, ERC721Upgradeable, IERC721EnumerableUpgradeable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
function __ERC721Enumerable_init() internal onlyInitializing {
}
function __ERC721Enumerable_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165Upgradeable, ERC721Upgradeable) returns (bool) {
return interfaceId == type(IERC721EnumerableUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
require(index < ERC721Upgradeable.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _allTokens.length;
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < ERC721EnumerableUpgradeable.totalSupply(), "ERC721Enumerable: global index out of bounds");
return _allTokens[index];
}
/**
* @dev See {ERC721-_beforeTokenTransfer}.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual override {
super._beforeTokenTransfer(from, to, firstTokenId, batchSize);
if (batchSize > 1) {
// Will only trigger during construction. Batch transferring (minting) is not available afterwards.
revert("ERC721Enumerable: consecutive transfers not supported");
}
uint256 tokenId = firstTokenId;
if (from == address(0)) {
_addTokenToAllTokensEnumeration(tokenId);
} else if (from != to) {
_removeTokenFromOwnerEnumeration(from, tokenId);
}
if (to == address(0)) {
_removeTokenFromAllTokensEnumeration(tokenId);
} else if (to != from) {
_addTokenToOwnerEnumeration(to, tokenId);
}
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
uint256 length = ERC721Upgradeable.balanceOf(to);
_ownedTokens[to][length] = tokenId;
_ownedTokensIndex[tokenId] = length;
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
// To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = ERC721Upgradeable.balanceOf(from) - 1;
uint256 tokenIndex = _ownedTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
}
// This also deletes the contents at the last position of the array
delete _ownedTokensIndex[tokenId];
delete _ownedTokens[from][lastTokenIndex];
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
// To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
// rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
// This also deletes the contents at the last position of the array
delete _allTokensIndex[tokenId];
_allTokens.pop();
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[46] private __gap;
}
@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721EnumerableUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)
pragma solidity ^0.8.0;
import "../IERC721Upgradeable.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721EnumerableUpgradeable is IERC721Upgradeable {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)
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);
}
@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/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.8.0/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 functionCallWithValue(target, data, 0, "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");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or 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 {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)
pragma solidity ^0.8.0;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
@openzeppelin/contracts-upgradeable/utils/MulticallUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.5) (utils/Multicall.sol)
pragma solidity ^0.8.0;
import "./AddressUpgradeable.sol";
import "./ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Provides a function to batch together multiple calls in a single external call.
*
* Consider any assumption about calldata validation performed by the sender may be violated if it's not especially
* careful about sending transactions invoking {multicall}. For example, a relay address that filters function
* selectors won't filter calls nested within a {multicall} operation.
*
* NOTE: Since 5.0.1 and 4.9.4, this contract identifies non-canonical contexts (i.e. `msg.sender` is not {_msgSender}).
* If a non-canonical context is identified, the following self `delegatecall` appends the last bytes of `msg.data`
* to the subcall. This makes it safe to use with {ERC2771Context}. Contexts that don't affect the resolution of
* {_msgSender} are not propagated to subcalls.
*
* _Available since v4.1._
*/
abstract contract MulticallUpgradeable is Initializable, ContextUpgradeable {
function __Multicall_init() internal onlyInitializing {
}
function __Multicall_init_unchained() internal onlyInitializing {
}
/**
* @dev Receives and executes a batch of function calls on this contract.
* @custom:oz-upgrades-unsafe-allow-reachable delegatecall
*/
function multicall(bytes[] calldata data) external virtual returns (bytes[] memory results) {
bytes memory context = msg.sender == _msgSender()
? new bytes(0)
: msg.data[msg.data.length - _contextSuffixLength():];
results = new bytes[](data.length);
for (uint256 i = 0; i < data.length; i++) {
results[i] = AddressUpgradeable.functionDelegateCall(address(this), bytes.concat(data[i], context));
}
return results;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
import "./math/MathUpgradeable.sol";
import "./math/SignedMathUpgradeable.sol";
/**
* @dev String operations.
*/
library StringsUpgradeable {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = MathUpgradeable.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMathUpgradeable.abs(value))));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, MathUpgradeable.log256(value) + 1);
}
}
/**
* @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] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol)
pragma solidity ^0.8.0;
import "../StringsUpgradeable.sol";
/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/
library ECDSAUpgradeable {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV // Deprecated in v4.8
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature` or error string. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
*
* _Available since v4.2._
*/
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
// the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
// signatures from current libraries generate a unique signature with an s-value in the lower half order.
//
// If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
// with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
// vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
/**
* @dev Returns an Ethereum Signed Message, created from a `hash`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, hash)
message := keccak256(0x00, 0x3c)
}
}
/**
* @dev Returns an Ethereum Signed Message, created from `s`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", StringsUpgradeable.toString(s.length), s));
}
/**
* @dev Returns an Ethereum Signed Typed Data, created from a
* `domainSeparator` and a `structHash`. This produces hash corresponding
* to the one signed with the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
* JSON-RPC method as part of EIP-712.
*
* See {recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
/// @solidity memory-safe-assembly
assembly {
let ptr := mload(0x40)
mstore(ptr, "\x19\x01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
data := keccak256(ptr, 0x42)
}
}
/**
* @dev Returns an Ethereum Signed Data with intended validator, created from a
* `validator` and `data` according to the version 0 of EIP-191.
*
* See {recover}.
*/
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x00", validator, data));
}
}
@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
import {Initializable} from "../../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 onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
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);
}
@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library MathUpgradeable {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv overflow");
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
@openzeppelin/contracts-upgradeable/utils/math/SignedMathUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMathUpgradeable {
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}
@openzeppelin/contracts/token/ERC20/IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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);
}
contracts/interfaces/IConfigurableGuildRewardNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import { IGuildRewardNFTFactory } from "./IGuildRewardNFTFactory.sol";
import { IMaxSupply } from "./IMaxSupply.sol";
/// @title An NFT distributed as a reward for Guild.xyz users.
interface IConfigurableGuildRewardNFT is IMaxSupply {
/// @notice The address of the proxy to be used when interacting with the factory.
/// @dev Used to access the factory's address when interacting through minimal proxies.
/// @return factoryAddress The address of the factory.
function factoryProxy() external view returns (address factoryAddress);
/// @notice The maximum amount of tokens a Guild user can claim from the token.
/// @dev Doesn't matter if they are claimed in the same transaction or separately.
/// @return mintableAmountPerUser The amount of tokens. Unlimited if zero.
function mintableAmountPerUser() external view returns (uint256 mintableAmountPerUser);
/// @notice The time interval while a signature is valid.
/// @return validity The time interval in seconds.
// solhint-disable func-name-mixedcase
function SIGNATURE_VALIDITY() external pure returns (uint256 validity);
/// @notice Returns the number of tokens the user claimed.
/// @dev Analogous to balanceOf(address), but works with Guild user ids.
/// @param userId The id of the user on Guild.
/// @return amount The number of tokens the userId has claimed.
function balanceOf(uint256 userId) external view returns (uint256 amount);
/// @notice Sets metadata and the associated addresses.
/// @dev Initializer function callable only once.
/// @param nftConfig See struct ConfigurableNFTConfig in IGuildRewardNFTFactory.
/// @param factoryProxyAddress The address of the factory.
function initialize(
IGuildRewardNFTFactory.ConfigurableNFTConfig memory nftConfig,
address factoryProxyAddress
) external;
// Disable solhint for the next functions because this seems to be the only way the docgen plugin works correctly.
// solhint-disable max-line-length
/// @notice Claims tokens to the given address.
/// @param amount The amount of tokens to mint. Should be less or equal to mintableAmountPerUser.
/// @param receiver The address that receives the token.
/// @param userId The id of the user on Guild.
/// @param signedAt The timestamp marking the time when the data were signed.
/// @param signature The following signed by validSigner: amount, signedAt, receiver, userId, chainId, the contract's address.
function claim(
uint256 amount,
address receiver,
uint256 userId,
uint256 signedAt,
bytes calldata signature
) external payable;
/// @notice Burns tokens from the sender.
/// @param tokenIds The tokenIds to burn. All of them should belong to userId.
/// @param userId The id of the user on Guild.
/// @param signedAt The timestamp marking the time when the data were signed.
/// @param signature The following signed by validSigner: amount, signedAt, receiver, userId, chainId, the contract's address.
function burn(uint256[] calldata tokenIds, uint256 userId, uint256 signedAt, bytes calldata signature) external;
// solhint-enable max-line-length
/// @notice Sets the locked (i.e. soulboundness) status of all of the tokens in this NFT.
/// @dev Only callable by the owner.
/// @param newLocked Whether the token should be soulbound or not.
function setLocked(bool newLocked) external;
/// @notice Sets the amount of tokens a user can mint from the token.
/// @dev Only callable by the owner.
/// @param newAmount The new amount a user can mint from the token. Unlimited if zero.
function setMintableAmountPerUser(uint256 newAmount) external;
/// @notice Updates the cid for tokenURI.
/// @dev Only callable by the owner.
/// @param newCid The new cid that points to the updated image.
function updateTokenURI(string calldata newCid) external;
/// @notice Event emitted whenever a claim succeeds.
/// @param receiver The address that received the tokens.
/// @param tokenId The id of the token.
event Claimed(address indexed receiver, uint256 tokenId);
/// @notice Event emitted whenever the cid is updated.
event MetadataUpdate();
/// @notice Event emitted when the mintableAmountPerUser is changed.
/// @param newAmount The new amount a user can mint from the token.
event MintableAmountPerUserChanged(uint256 newAmount);
/// @notice Error thrown when the token is already claimed.
error AlreadyClaimed();
/// @notice Error thrown when the signature is already expired.
error ExpiredSignature();
/// @notice Error thrown when an incorrect amount of fee is attempted to be paid.
/// @param paid The amount of funds received.
/// @param requiredAmount The amount of fees required for claiming a single token.
error IncorrectFee(uint256 paid, uint256 requiredAmount);
/// @notice Error thrown when the sender is not permitted to do a specific action.
error IncorrectSender();
/// @notice Error thrown when the supplied signature is invalid.
error IncorrectSignature();
}
contracts/interfaces/IERC5192.sol
// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.0;
interface IERC5192 {
/// @notice Emitted when the locking status is changed to locked.
/// @dev If a token is minted and the status is locked, this event should be emitted.
/// @param tokenId The identifier for a token.
event Locked(uint256 tokenId);
/// @notice Emitted when the locking status is changed to unlocked.
/// @dev If a token is minted and the status is unlocked, this event should be emitted.
/// @param tokenId The identifier for a token.
event Unlocked(uint256 tokenId);
/// @notice Returns the locking status of an Soulbound Token
/// @dev SBTs assigned to zero address are considered invalid, and queries
/// about them do throw.
/// @param tokenId The identifier for an SBT.
function locked(uint256 tokenId) external view returns (bool);
}
contracts/interfaces/IGuildRewardNFTFactory.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title A simple factory deploying minimal proxy contracts for Guild reward NFTs.
interface IGuildRewardNFTFactory {
/// @notice The type of the contract.
/// @dev Used as an identifier. Should be expanded in future updates.
enum ContractType {
BASIC_NFT,
CONFIGURABLE_NFT
}
/// @notice Input parameters of the deployConfigurableNFT function.
/// @dev Needed to prevent "stack too deep" errors.
/// @param name The name of the NFT to be created.
/// @param symbol The symbol of the NFT to be created.
/// @param cid The cid used to construct the tokenURI of the NFT to be created.
/// @param tokenOwner The address that will be the owner of the deployed token.
/// @param tokenTreasury The address that will collect the prices of the minted tokens.
/// @param tokenFee The price of every mint in wei.
/// @param soulbound Whether the token should be soulbound.
/// @param maxSupply The maximum number of tokens that users will ever be able to mint.
/// @param mintableAmountPerUser The maximum amount a user will be able to mint from the deployed token.
struct ConfigurableNFTConfig {
string name;
string symbol;
string cid;
address tokenOwner;
address payable treasury;
uint256 tokenFee;
bool soulbound;
uint256 maxSupply;
uint256 mintableAmountPerUser;
}
/// @notice Information about a specific deployment.
/// @param contractAddress The address where the contract/clone is deployed.
/// @param contractType The type of the contract.
struct Deployment {
address contractAddress;
ContractType contractType;
}
/// @return signer The address that signs the metadata.
function validSigner() external view returns (address signer);
/// @notice Maps deployed implementation contract addresses to contract types.
/// @param contractType The type of the contract.
/// @return contractAddress The address of the deployed NFT contract.
function nftImplementations(ContractType contractType) external view returns (address contractAddress);
/// @notice Sets the associated addresses.
/// @dev Initializer function callable only once.
/// @param treasuryAddress The address that will receive the fees.
/// @param fee The Guild base fee for every deployment.
/// @param validSignerAddress The address that will sign the metadata.
function initialize(address payable treasuryAddress, uint256 fee, address validSignerAddress) external;
/// @notice Deploys a minimal proxy for a basic NFT.
/// @param name The name of the NFT to be created.
/// @param symbol The symbol of the NFT to be created.
/// @param cid The cid used to construct the tokenURI of the NFT to be created.
/// @param tokenOwner The address that will be the owner of the deployed token.
/// @param tokenTreasury The address that will collect the prices of the minted tokens.
/// @param tokenFee The price of every mint in wei.
function deployBasicNFT(
string calldata name,
string calldata symbol,
string calldata cid,
address tokenOwner,
address payable tokenTreasury,
uint256 tokenFee
) external;
/// @notice Deploys a minimal proxy for a configurable NFT.
/// @param nftConfig The config to initialize the token to be deployed with.
function deployConfigurableNFT(ConfigurableNFTConfig memory nftConfig) external;
/// @notice Returns the reward NFT addresses for a guild.
/// @param deployer The address that deployed the tokens.
/// @return tokens The addresses of the tokens deployed by deployer.
function getDeployedTokenContracts(address deployer) external view returns (Deployment[] memory tokens);
/// @notice Sets the address that signs the metadata.
/// @dev Callable only by the owner.
/// @param newValidSigner The new address of validSigner.
function setValidSigner(address newValidSigner) external;
/// @notice Sets the address of the contract where a specific NFT is implemented.
/// @dev Callable only by the owner.
/// @param contractType The type of the contract.
/// @param newNFT The address of the deployed NFT contract.
function setNFTImplementation(ContractType contractType, address newNFT) external;
/// @notice Event emitted when an NFT implementation is changed.
/// @param contractType The type of the contract.
/// @param newNFT The new address of the NFT implementation.
event ImplementationChanged(ContractType contractType, address newNFT);
/// @notice Event emitted when a new NFT is deployed.
/// @param deployer The address that deployed the token.
/// @param tokenAddress The address of the token.
/// @param contractType The type of the NFT deployed.
event RewardNFTDeployed(address deployer, address tokenAddress, ContractType contractType);
/// @notice Event emitted when the validSigner is changed.
/// @param newValidSigner The new address of validSigner.
event ValidSignerChanged(address newValidSigner);
}
contracts/interfaces/IMaxSupply.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IMaxSupply {
/// @notice The maximum number of tokens that can ever be minted.
/// @return count The number of tokens. Unlimited if zero.
function maxSupply() external view returns (uint256 count);
/// @notice Sets the maximum number of tokens that can ever be minted.
/// @dev Only callable by the owner.
/// @param newMaxSupply The number of tokens. Unlimited if zero.
function setMaxSupply(uint256 newMaxSupply) external;
/// @notice Event emitted when the maxSupply is changed.
/// @param newMaxSupply The number of tokens.
event MaxSupplyChanged(uint256 newMaxSupply);
/// @notice Error thrown when the tokenId is higher than the maximum supply.
/// @param maxSupply The maximum supply of the token.
error MaxSupplyReached(uint256 maxSupply);
}
contracts/interfaces/ITreasuryManager.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title A contract that manages fee-related functionality.
interface ITreasuryManager {
/// @notice Sets the minting fee.
/// @dev Callable only by the owner.
/// @param newFee The new fee in base units.
function setFee(uint256 newFee) external;
/// @notice Sets the address that receives the fees.
/// @dev Callable only by the owner.
/// @param newTreasury The new address of the treasury.
function setTreasury(address payable newTreasury) external;
/// @notice The base minting fee of a token.
/// @return fee The amount of the fee in base units.
function fee() external view returns (uint256 fee);
/// @notice Sets the fee override for a specific token.
/// @dev Callable only by the owner.
/// @param tokenAddress The address of the token.
/// @param newFee The new fee amount in base units.
function setFeeOverride(address tokenAddress, uint256 newFee) external;
/// @notice The minting fee of a token for a specific caller.
/// @param tokenAddress The address of the token.
/// @return tokenFee The fee for the token in base units.
function getFeeWithOverrides(address tokenAddress) external view returns (uint256 tokenFee);
/// @notice Gets both the fee and the treasury address for optimization purposes.
/// @dev Gets the fee for the caller - might only make sense to call it from a contract.
/// @return tokenFee The fee for the token in base units.
/// @return treasuryAddress The address of the treasury.
function getFeeData() external view returns (uint256 tokenFee, address payable treasuryAddress);
/// @notice Returns the address that receives the fees.
function treasury() external view returns (address payable);
/// @notice Event emitted when a token's fee is changed.
/// @param newFee The new amount of fee in base units.
event FeeChanged(uint256 newFee);
/// @notice Event emitted when a fee override is set.
/// @param tokenAddress The address of the token.
/// @param newFee The new fee amount in base units.
event FeeOverrideChanged(address tokenAddress, uint256 newFee);
/// @notice Event emitted when the treasury address is changed.
/// @param newTreasury The new address of the treasury.
event TreasuryChanged(address newTreasury);
}
contracts/lib/LibTransfer.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
/// @title Library for functions related to transfers.
library LibTransfer {
/// @notice Error thrown when sending ether fails.
/// @param recipient The address that could not receive the ether.
error FailedToSendEther(address recipient);
/// @notice Error thrown when an ERC20 transfer failed.
/// @param from The sender of the token.
/// @param to The recipient of the token.
error TransferFailed(address from, address to);
/// @notice Sends ether to an address, forwarding all available gas and reverting on errors.
/// @param recipient The recipient of the ether.
/// @param amount The amount of ether to send in base units.
function sendEther(address payable recipient, uint256 amount) internal {
// solhint-disable-next-line avoid-low-level-calls
(bool success, ) = recipient.call{ value: amount }("");
if (!success) revert FailedToSendEther(recipient);
}
/// @notice Sends an ERC20 token to an address and reverts if the transfer returns false.
/// @dev Wrapper for {IERC20-transfer}.
/// @param to The recipient of the tokens.
/// @param token The address of the token to send.
/// @param amount The amount of the token to send in base units.
function sendToken(address to, address token, uint256 amount) internal {
if (!IERC20(token).transfer(to, amount)) revert TransferFailed(msg.sender, address(this));
}
/// @notice Sends an ERC20 token to an address from another address and reverts if transferFrom returns false.
/// @dev Wrapper for {IERC20-transferFrom}.
/// @param to The recipient of the tokens.
/// @param token The address of the token to send.
/// @param from The source of the tokens.
/// @param amount The amount of the token to send in base units.
function sendTokenFrom(address to, address from, address token, uint256 amount) internal {
if (!IERC20(token).transferFrom(from, to, amount)) revert TransferFailed(msg.sender, address(this));
}
}
contracts/token/OptionallySoulboundERC721.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
/* solhint-disable max-line-length */
import { IERC5192 } from "../interfaces/IERC5192.sol";
import { ERC721Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import { IERC721Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
import { ERC721EnumerableUpgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import { IERC721EnumerableUpgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721EnumerableUpgradeable.sol";
/* solhint-enable max-line-length */
/// @title An enumerable ERC721 that's optionally soulbound.
/// @notice Allowance and transfer-related functions are disabled in soulbound mode.
/// @dev Inheriting from upgradeable contracts here - even though we're using it in a non-upgradeable way,
/// we still want it to be initializable
contract OptionallySoulboundERC721 is ERC721Upgradeable, ERC721EnumerableUpgradeable, IERC5192 {
/// @notice Whether the token is set as soulbound.
bool internal soulbound;
/// @notice Error thrown when trying to query info about a token that's not (yet) minted.
/// @param tokenId The queried id.
error NonExistentToken(uint256 tokenId);
/// @notice Error thrown when a function's execution is not possible, because the soulbound mode is on.
error Soulbound();
/// @notice Reverts the function execution if the token is soulbound.
modifier checkSoulbound() {
if (soulbound) revert Soulbound();
_;
}
// solhint-disable-next-line func-name-mixedcase
function __OptionallySoulboundERC721_init(
string memory name_,
string memory symbol_,
bool soulbound_
) internal onlyInitializing {
soulbound = soulbound_;
__ERC721_init(name_, symbol_);
__ERC721Enumerable_init();
}
/// @inheritdoc ERC721EnumerableUpgradeable
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721EnumerableUpgradeable, ERC721Upgradeable) returns (bool) {
return
interfaceId == type(IERC5192).interfaceId ||
interfaceId == type(IERC721EnumerableUpgradeable).interfaceId ||
super.supportsInterface(interfaceId);
}
function locked(uint256 tokenId) external view returns (bool) {
if (!_exists(tokenId)) revert NonExistentToken(tokenId);
return soulbound;
}
/// @notice Whether all the tokens in the NFT are soulbound.
/// @dev Added as a convenient alternative to locked(tokenId) that does not require a minted token.
function locked() external view returns (bool) {
return soulbound;
}
function approve(
address to,
uint256 tokenId
) public virtual override(IERC721Upgradeable, ERC721Upgradeable) checkSoulbound {
super.approve(to, tokenId);
}
function setApprovalForAll(
address operator,
bool approved
) public virtual override(IERC721Upgradeable, ERC721Upgradeable) checkSoulbound {
super.setApprovalForAll(operator, approved);
}
function isApprovedForAll(
address owner,
address operator
) public view virtual override(IERC721Upgradeable, ERC721Upgradeable) checkSoulbound returns (bool) {
return super.isApprovedForAll(owner, operator);
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(IERC721Upgradeable, ERC721Upgradeable) checkSoulbound {
super.transferFrom(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(IERC721Upgradeable, ERC721Upgradeable) checkSoulbound {
super.safeTransferFrom(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override(IERC721Upgradeable, ERC721Upgradeable) checkSoulbound {
super.safeTransferFrom(from, to, tokenId, data);
}
/// @dev Used for minting/burning even when soulbound.
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual override(ERC721EnumerableUpgradeable, ERC721Upgradeable) {
super._beforeTokenTransfer(from, to, firstTokenId, batchSize);
}
}
contracts/utils/TreasuryManager.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import { ITreasuryManager } from "../interfaces/ITreasuryManager.sol";
import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
/// @title A contract that manages fee-related functionality.
contract TreasuryManager is ITreasuryManager, Initializable, OwnableUpgradeable {
address payable public treasury;
uint256 public fee;
/// @notice Fee overrides to be able to discount fees for specific guilds.
mapping(address token => uint256 fee) internal _feeOverrides;
/// @notice Empty space reserved for future updates.
uint256[47] private __gap;
/// @param treasury_ The address that will receive the fees.
/// @param fee_ The fee amount in wei.
// solhint-disable-next-line func-name-mixedcase
function __TreasuryManager_init(address payable treasury_, uint256 fee_) internal onlyInitializing {
treasury = treasury_;
fee = fee_;
}
function setFee(uint256 newFee) external onlyOwner {
fee = newFee;
emit FeeChanged(newFee);
}
function setFeeOverride(address tokenAddress, uint256 newFee) external onlyOwner {
_feeOverrides[tokenAddress] = newFee;
emit FeeOverrideChanged(tokenAddress, newFee);
}
function setTreasury(address payable newTreasury) external onlyOwner {
treasury = newTreasury;
emit TreasuryChanged(newTreasury);
}
function getFeeWithOverrides(address tokenAddress) public view returns (uint256) {
uint256 feeOverride = _feeOverrides[tokenAddress];
return feeOverride != 0 ? feeOverride : fee;
}
function getFeeData() external view returns (uint256 tokenFee, address payable treasuryAddress) {
uint256 correctFee = getFeeWithOverrides(msg.sender);
return (correctFee, treasury);
}
}
Compiler Settings
{"outputSelection":{"*":{"*":["*"],"":["*"]}},"optimizer":{"runs":200,"enabled":true},"libraries":{}}
Contract ABI
[{"type":"error","name":"AlreadyClaimed","inputs":[]},{"type":"error","name":"ExpiredSignature","inputs":[]},{"type":"error","name":"FailedToSendEther","inputs":[{"type":"address","name":"recipient","internalType":"address"}]},{"type":"error","name":"IncorrectFee","inputs":[{"type":"uint256","name":"paid","internalType":"uint256"},{"type":"uint256","name":"requiredAmount","internalType":"uint256"}]},{"type":"error","name":"IncorrectSender","inputs":[]},{"type":"error","name":"IncorrectSignature","inputs":[]},{"type":"error","name":"MaxSupplyReached","inputs":[{"type":"uint256","name":"maxSupply","internalType":"uint256"}]},{"type":"error","name":"NonExistentToken","inputs":[{"type":"uint256","name":"tokenId","internalType":"uint256"}]},{"type":"error","name":"Soulbound","inputs":[]},{"type":"event","name":"Approval","inputs":[{"type":"address","name":"owner","internalType":"address","indexed":true},{"type":"address","name":"approved","internalType":"address","indexed":true},{"type":"uint256","name":"tokenId","internalType":"uint256","indexed":true}],"anonymous":false},{"type":"event","name":"ApprovalForAll","inputs":[{"type":"address","name":"owner","internalType":"address","indexed":true},{"type":"address","name":"operator","internalType":"address","indexed":true},{"type":"bool","name":"approved","internalType":"bool","indexed":false}],"anonymous":false},{"type":"event","name":"Claimed","inputs":[{"type":"address","name":"receiver","internalType":"address","indexed":true},{"type":"uint256","name":"tokenId","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"FeeChanged","inputs":[{"type":"uint256","name":"newFee","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"FeeOverrideChanged","inputs":[{"type":"address","name":"tokenAddress","internalType":"address","indexed":false},{"type":"uint256","name":"newFee","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"Initialized","inputs":[{"type":"uint8","name":"version","internalType":"uint8","indexed":false}],"anonymous":false},{"type":"event","name":"Locked","inputs":[{"type":"uint256","name":"tokenId","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"MaxSupplyChanged","inputs":[{"type":"uint256","name":"newMaxSupply","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"MetadataUpdate","inputs":[],"anonymous":false},{"type":"event","name":"MintableAmountPerUserChanged","inputs":[{"type":"uint256","name":"newAmount","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"OwnershipTransferred","inputs":[{"type":"address","name":"previousOwner","internalType":"address","indexed":true},{"type":"address","name":"newOwner","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"Transfer","inputs":[{"type":"address","name":"from","internalType":"address","indexed":true},{"type":"address","name":"to","internalType":"address","indexed":true},{"type":"uint256","name":"tokenId","internalType":"uint256","indexed":true}],"anonymous":false},{"type":"event","name":"TreasuryChanged","inputs":[{"type":"address","name":"newTreasury","internalType":"address","indexed":false}],"anonymous":false},{"type":"event","name":"Unlocked","inputs":[{"type":"uint256","name":"tokenId","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"SIGNATURE_VALIDITY","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"approve","inputs":[{"type":"address","name":"to","internalType":"address"},{"type":"uint256","name":"tokenId","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"balanceOf","inputs":[{"type":"address","name":"owner","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"amount","internalType":"uint256"}],"name":"balanceOf","inputs":[{"type":"uint256","name":"userId","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"burn","inputs":[{"type":"uint256[]","name":"tokenIds","internalType":"uint256[]"},{"type":"uint256","name":"userId","internalType":"uint256"},{"type":"uint256","name":"signedAt","internalType":"uint256"},{"type":"bytes","name":"signature","internalType":"bytes"}]},{"type":"function","stateMutability":"payable","outputs":[],"name":"claim","inputs":[{"type":"uint256","name":"amount","internalType":"uint256"},{"type":"address","name":"receiver","internalType":"address"},{"type":"uint256","name":"userId","internalType":"uint256"},{"type":"uint256","name":"signedAt","internalType":"uint256"},{"type":"bytes","name":"signature","internalType":"bytes"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"factoryProxy","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"fee","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"getApproved","inputs":[{"type":"uint256","name":"tokenId","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"tokenFee","internalType":"uint256"},{"type":"address","name":"treasuryAddress","internalType":"address payable"}],"name":"getFeeData","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getFeeWithOverrides","inputs":[{"type":"address","name":"tokenAddress","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"initialize","inputs":[{"type":"tuple","name":"nftConfig","internalType":"struct IGuildRewardNFTFactory.ConfigurableNFTConfig","components":[{"type":"string","name":"name","internalType":"string"},{"type":"string","name":"symbol","internalType":"string"},{"type":"string","name":"cid","internalType":"string"},{"type":"address","name":"tokenOwner","internalType":"address"},{"type":"address","name":"treasury","internalType":"address payable"},{"type":"uint256","name":"tokenFee","internalType":"uint256"},{"type":"bool","name":"soulbound","internalType":"bool"},{"type":"uint256","name":"maxSupply","internalType":"uint256"},{"type":"uint256","name":"mintableAmountPerUser","internalType":"uint256"}]},{"type":"address","name":"factoryProxyAddress","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isApprovedForAll","inputs":[{"type":"address","name":"owner","internalType":"address"},{"type":"address","name":"operator","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"locked","inputs":[{"type":"uint256","name":"tokenId","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"locked","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"maxSupply","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"mintableAmountPerUser","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"bytes[]","name":"results","internalType":"bytes[]"}],"name":"multicall","inputs":[{"type":"bytes[]","name":"data","internalType":"bytes[]"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"string","name":"","internalType":"string"}],"name":"name","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"owner","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"ownerOf","inputs":[{"type":"uint256","name":"tokenId","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"renounceOwnership","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"safeTransferFrom","inputs":[{"type":"address","name":"from","internalType":"address"},{"type":"address","name":"to","internalType":"address"},{"type":"uint256","name":"tokenId","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"safeTransferFrom","inputs":[{"type":"address","name":"from","internalType":"address"},{"type":"address","name":"to","internalType":"address"},{"type":"uint256","name":"tokenId","internalType":"uint256"},{"type":"bytes","name":"data","internalType":"bytes"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setApprovalForAll","inputs":[{"type":"address","name":"operator","internalType":"address"},{"type":"bool","name":"approved","internalType":"bool"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setFee","inputs":[{"type":"uint256","name":"newFee","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setFeeOverride","inputs":[{"type":"address","name":"tokenAddress","internalType":"address"},{"type":"uint256","name":"newFee","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setLocked","inputs":[{"type":"bool","name":"newLocked","internalType":"bool"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setMaxSupply","inputs":[{"type":"uint256","name":"newMaxSupply","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setMintableAmountPerUser","inputs":[{"type":"uint256","name":"newAmount","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setTreasury","inputs":[{"type":"address","name":"newTreasury","internalType":"address payable"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"supportsInterface","inputs":[{"type":"bytes4","name":"interfaceId","internalType":"bytes4"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"string","name":"","internalType":"string"}],"name":"symbol","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"tokenByIndex","inputs":[{"type":"uint256","name":"index","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"tokenOfOwnerByIndex","inputs":[{"type":"address","name":"owner","internalType":"address"},{"type":"uint256","name":"index","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"string","name":"","internalType":"string"}],"name":"tokenURI","inputs":[{"type":"uint256","name":"tokenId","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"totalSupply","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"transferFrom","inputs":[{"type":"address","name":"from","internalType":"address"},{"type":"address","name":"to","internalType":"address"},{"type":"uint256","name":"tokenId","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"transferOwnership","inputs":[{"type":"address","name":"newOwner","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address payable"}],"name":"treasury","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"updateTokenURI","inputs":[{"type":"string","name":"newCid","internalType":"string"}]}]
Contract Creation Code
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 ByteCode
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