Contract Name:
NFTDropMarket
Contract Source Code:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @author: manifold.xyz
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
/**
* @dev Royalty registry interface
*/
interface IRoyaltyRegistry is IERC165 {
event RoyaltyOverride(address owner, address tokenAddress, address royaltyAddress);
/**
* Override the location of where to look up royalty information for a given token contract.
* Allows for backwards compatibility and implementation of royalty logic for contracts that did not previously support them.
*
* @param tokenAddress - The token address you wish to override
* @param royaltyAddress - The royalty override address
*/
function setRoyaltyLookupAddress(address tokenAddress, address royaltyAddress) external returns (bool);
/**
* Returns royalty address location. Returns the tokenAddress by default, or the override if it exists
*
* @param tokenAddress - The token address you are looking up the royalty for
*/
function getRoyaltyLookupAddress(address tokenAddress) external view returns (address);
/**
* Returns the token address that an overrideAddress is set for.
* Note: will not be accurate if the override was created before this function was added.
*
* @param overrideAddress - The override address you are looking up the token for
*/
function getOverrideLookupTokenAddress(address overrideAddress) external view returns (address);
/**
* Whether or not the message sender can override the royalty address for the given token address
*
* @param tokenAddress - The token address you are looking up the royalty for
*/
function overrideAllowed(address tokenAddress) external view returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* 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;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuardUpgradeable is Initializable {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// On the first call to nonReentrant, _status will be _NOT_ENTERED
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return 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 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);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
pragma solidity ^0.8.0;
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControl {
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*
* _Available since v3.1._
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {AccessControl-_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) external;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @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);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)
pragma solidity ^0.8.0;
/**
* @dev These functions deal with verification of Merkle Tree proofs.
*
* The tree and the proofs can be generated using our
* https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
* You will find a quickstart guide in the readme.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
* OpenZeppelin's JavaScript library generates merkle trees that are safe
* against this attack out of the box.
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
/**
* @dev Calldata version of {verify}
*
* _Available since v4.7._
*/
function verifyCalldata(
bytes32[] calldata proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProofCalldata(proof, leaf) == root;
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Calldata version of {processProof}
*
* _Available since v4.7._
*/
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
*
* _Available since v4.7._
*/
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
/**
* @dev Calldata version of {multiProofVerify}
*
* CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
*
* _Available since v4.7._
*/
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves) == root;
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
* proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
* leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
* respectively.
*
* CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
* is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
* tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
*
* _Available since v4.7._
*/
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
// This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the merkle tree.
uint256 leavesLen = leaves.length;
uint256 totalHashes = proofFlags.length;
// Check proof validity.
require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
return hashes[totalHashes - 1];
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
/**
* @dev Calldata version of {processMultiProof}.
*
* CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
*
* _Available since v4.7._
*/
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
// This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the merkle tree.
uint256 leavesLen = leaves.length;
uint256 totalHashes = proofFlags.length;
// Check proof validity.
require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
return hashes[totalHashes - 1];
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/introspection/ERC165Checker.sol)
pragma solidity ^0.8.0;
import "./IERC165.sol";
/**
* @dev Library used to query support of an interface declared via {IERC165}.
*
* Note that these functions return the actual result of the query: they do not
* `revert` if an interface is not supported. It is up to the caller to decide
* what to do in these cases.
*/
library ERC165Checker {
// As per the EIP-165 spec, no interface should ever match 0xffffffff
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
/**
* @dev Returns true if `account` supports the {IERC165} interface.
*/
function supportsERC165(address account) internal view returns (bool) {
// Any contract that implements ERC165 must explicitly indicate support of
// InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
return
supportsERC165InterfaceUnchecked(account, type(IERC165).interfaceId) &&
!supportsERC165InterfaceUnchecked(account, _INTERFACE_ID_INVALID);
}
/**
* @dev Returns true if `account` supports the interface defined by
* `interfaceId`. Support for {IERC165} itself is queried automatically.
*
* See {IERC165-supportsInterface}.
*/
function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
// query support of both ERC165 as per the spec and support of _interfaceId
return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId);
}
/**
* @dev Returns a boolean array where each value corresponds to the
* interfaces passed in and whether they're supported or not. This allows
* you to batch check interfaces for a contract where your expectation
* is that some interfaces may not be supported.
*
* See {IERC165-supportsInterface}.
*
* _Available since v3.4._
*/
function getSupportedInterfaces(address account, bytes4[] memory interfaceIds)
internal
view
returns (bool[] memory)
{
// an array of booleans corresponding to interfaceIds and whether they're supported or not
bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);
// query support of ERC165 itself
if (supportsERC165(account)) {
// query support of each interface in interfaceIds
for (uint256 i = 0; i < interfaceIds.length; i++) {
interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]);
}
}
return interfaceIdsSupported;
}
/**
* @dev Returns true if `account` supports all the interfaces defined in
* `interfaceIds`. Support for {IERC165} itself is queried automatically.
*
* Batch-querying can lead to gas savings by skipping repeated checks for
* {IERC165} support.
*
* See {IERC165-supportsInterface}.
*/
function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
// query support of ERC165 itself
if (!supportsERC165(account)) {
return false;
}
// query support of each interface in interfaceIds
for (uint256 i = 0; i < interfaceIds.length; i++) {
if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) {
return false;
}
}
// all interfaces supported
return true;
}
/**
* @notice Query if a contract implements an interface, does not check ERC165 support
* @param account The address of the contract to query for support of an interface
* @param interfaceId The interface identifier, as specified in ERC-165
* @return true if the contract at account indicates support of the interface with
* identifier interfaceId, false otherwise
* @dev Assumes that account contains a contract that supports ERC165, otherwise
* the behavior of this method is undefined. This precondition can be checked
* with {supportsERC165}.
* Interface identification is specified in ERC-165.
*/
function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) {
// prepare call
bytes memory encodedParams = abi.encodeWithSelector(IERC165.supportsInterface.selector, interfaceId);
// perform static call
bool success;
uint256 returnSize;
uint256 returnValue;
assembly {
success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20)
returnSize := returndatasize()
returnValue := mload(0x00)
}
return success && returnSize >= 0x20 && returnValue > 0;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts 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 IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.0;
/**
* @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*
* Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
* all math on `uint256` and `int256` and then downcasting.
*/
library SafeCast {
/**
* @dev Returns the downcasted uint248 from uint256, reverting on
* overflow (when the input is greater than largest uint248).
*
* Counterpart to Solidity's `uint248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*
* _Available since v4.7._
*/
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
/**
* @dev Returns the downcasted uint240 from uint256, reverting on
* overflow (when the input is greater than largest uint240).
*
* Counterpart to Solidity's `uint240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*
* _Available since v4.7._
*/
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
/**
* @dev Returns the downcasted uint232 from uint256, reverting on
* overflow (when the input is greater than largest uint232).
*
* Counterpart to Solidity's `uint232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*
* _Available since v4.7._
*/
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
/**
* @dev Returns the downcasted uint224 from uint256, reverting on
* overflow (when the input is greater than largest uint224).
*
* Counterpart to Solidity's `uint224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*
* _Available since v4.2._
*/
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
/**
* @dev Returns the downcasted uint216 from uint256, reverting on
* overflow (when the input is greater than largest uint216).
*
* Counterpart to Solidity's `uint216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*
* _Available since v4.7._
*/
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
/**
* @dev Returns the downcasted uint208 from uint256, reverting on
* overflow (when the input is greater than largest uint208).
*
* Counterpart to Solidity's `uint208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*
* _Available since v4.7._
*/
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
/**
* @dev Returns the downcasted uint200 from uint256, reverting on
* overflow (when the input is greater than largest uint200).
*
* Counterpart to Solidity's `uint200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*
* _Available since v4.7._
*/
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
/**
* @dev Returns the downcasted uint192 from uint256, reverting on
* overflow (when the input is greater than largest uint192).
*
* Counterpart to Solidity's `uint192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*
* _Available since v4.7._
*/
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
/**
* @dev Returns the downcasted uint184 from uint256, reverting on
* overflow (when the input is greater than largest uint184).
*
* Counterpart to Solidity's `uint184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*
* _Available since v4.7._
*/
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
/**
* @dev Returns the downcasted uint176 from uint256, reverting on
* overflow (when the input is greater than largest uint176).
*
* Counterpart to Solidity's `uint176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*
* _Available since v4.7._
*/
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
/**
* @dev Returns the downcasted uint168 from uint256, reverting on
* overflow (when the input is greater than largest uint168).
*
* Counterpart to Solidity's `uint168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*
* _Available since v4.7._
*/
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
/**
* @dev Returns the downcasted uint160 from uint256, reverting on
* overflow (when the input is greater than largest uint160).
*
* Counterpart to Solidity's `uint160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*
* _Available since v4.7._
*/
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
/**
* @dev Returns the downcasted uint152 from uint256, reverting on
* overflow (when the input is greater than largest uint152).
*
* Counterpart to Solidity's `uint152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*
* _Available since v4.7._
*/
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
/**
* @dev Returns the downcasted uint144 from uint256, reverting on
* overflow (when the input is greater than largest uint144).
*
* Counterpart to Solidity's `uint144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*
* _Available since v4.7._
*/
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
/**
* @dev Returns the downcasted uint136 from uint256, reverting on
* overflow (when the input is greater than largest uint136).
*
* Counterpart to Solidity's `uint136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*
* _Available since v4.7._
*/
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*
* _Available since v2.5._
*/
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
/**
* @dev Returns the downcasted uint120 from uint256, reverting on
* overflow (when the input is greater than largest uint120).
*
* Counterpart to Solidity's `uint120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*
* _Available since v4.7._
*/
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
/**
* @dev Returns the downcasted uint112 from uint256, reverting on
* overflow (when the input is greater than largest uint112).
*
* Counterpart to Solidity's `uint112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*
* _Available since v4.7._
*/
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
/**
* @dev Returns the downcasted uint104 from uint256, reverting on
* overflow (when the input is greater than largest uint104).
*
* Counterpart to Solidity's `uint104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*
* _Available since v4.7._
*/
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
/**
* @dev Returns the downcasted uint96 from uint256, reverting on
* overflow (when the input is greater than largest uint96).
*
* Counterpart to Solidity's `uint96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*
* _Available since v4.2._
*/
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
/**
* @dev Returns the downcasted uint88 from uint256, reverting on
* overflow (when the input is greater than largest uint88).
*
* Counterpart to Solidity's `uint88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*
* _Available since v4.7._
*/
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
/**
* @dev Returns the downcasted uint80 from uint256, reverting on
* overflow (when the input is greater than largest uint80).
*
* Counterpart to Solidity's `uint80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*
* _Available since v4.7._
*/
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
/**
* @dev Returns the downcasted uint72 from uint256, reverting on
* overflow (when the input is greater than largest uint72).
*
* Counterpart to Solidity's `uint72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*
* _Available since v4.7._
*/
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*
* _Available since v2.5._
*/
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
/**
* @dev Returns the downcasted uint56 from uint256, reverting on
* overflow (when the input is greater than largest uint56).
*
* Counterpart to Solidity's `uint56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*
* _Available since v4.7._
*/
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
/**
* @dev Returns the downcasted uint48 from uint256, reverting on
* overflow (when the input is greater than largest uint48).
*
* Counterpart to Solidity's `uint48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*
* _Available since v4.7._
*/
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
/**
* @dev Returns the downcasted uint40 from uint256, reverting on
* overflow (when the input is greater than largest uint40).
*
* Counterpart to Solidity's `uint40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*
* _Available since v4.7._
*/
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*
* _Available since v2.5._
*/
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
/**
* @dev Returns the downcasted uint24 from uint256, reverting on
* overflow (when the input is greater than largest uint24).
*
* Counterpart to Solidity's `uint24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*
* _Available since v4.7._
*/
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*
* _Available since v2.5._
*/
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*
* _Available since v2.5._
*/
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*
* _Available since v3.0._
*/
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
/**
* @dev Returns the downcasted int248 from int256, reverting on
* overflow (when the input is less than smallest int248 or
* greater than largest int248).
*
* Counterpart to Solidity's `int248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*
* _Available since v4.7._
*/
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
/**
* @dev Returns the downcasted int240 from int256, reverting on
* overflow (when the input is less than smallest int240 or
* greater than largest int240).
*
* Counterpart to Solidity's `int240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*
* _Available since v4.7._
*/
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
/**
* @dev Returns the downcasted int232 from int256, reverting on
* overflow (when the input is less than smallest int232 or
* greater than largest int232).
*
* Counterpart to Solidity's `int232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*
* _Available since v4.7._
*/
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
/**
* @dev Returns the downcasted int224 from int256, reverting on
* overflow (when the input is less than smallest int224 or
* greater than largest int224).
*
* Counterpart to Solidity's `int224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*
* _Available since v4.7._
*/
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
/**
* @dev Returns the downcasted int216 from int256, reverting on
* overflow (when the input is less than smallest int216 or
* greater than largest int216).
*
* Counterpart to Solidity's `int216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*
* _Available since v4.7._
*/
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
/**
* @dev Returns the downcasted int208 from int256, reverting on
* overflow (when the input is less than smallest int208 or
* greater than largest int208).
*
* Counterpart to Solidity's `int208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*
* _Available since v4.7._
*/
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
/**
* @dev Returns the downcasted int200 from int256, reverting on
* overflow (when the input is less than smallest int200 or
* greater than largest int200).
*
* Counterpart to Solidity's `int200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*
* _Available since v4.7._
*/
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
/**
* @dev Returns the downcasted int192 from int256, reverting on
* overflow (when the input is less than smallest int192 or
* greater than largest int192).
*
* Counterpart to Solidity's `int192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*
* _Available since v4.7._
*/
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
/**
* @dev Returns the downcasted int184 from int256, reverting on
* overflow (when the input is less than smallest int184 or
* greater than largest int184).
*
* Counterpart to Solidity's `int184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*
* _Available since v4.7._
*/
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
/**
* @dev Returns the downcasted int176 from int256, reverting on
* overflow (when the input is less than smallest int176 or
* greater than largest int176).
*
* Counterpart to Solidity's `int176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*
* _Available since v4.7._
*/
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
/**
* @dev Returns the downcasted int168 from int256, reverting on
* overflow (when the input is less than smallest int168 or
* greater than largest int168).
*
* Counterpart to Solidity's `int168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*
* _Available since v4.7._
*/
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
/**
* @dev Returns the downcasted int160 from int256, reverting on
* overflow (when the input is less than smallest int160 or
* greater than largest int160).
*
* Counterpart to Solidity's `int160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*
* _Available since v4.7._
*/
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
/**
* @dev Returns the downcasted int152 from int256, reverting on
* overflow (when the input is less than smallest int152 or
* greater than largest int152).
*
* Counterpart to Solidity's `int152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*
* _Available since v4.7._
*/
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
/**
* @dev Returns the downcasted int144 from int256, reverting on
* overflow (when the input is less than smallest int144 or
* greater than largest int144).
*
* Counterpart to Solidity's `int144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*
* _Available since v4.7._
*/
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
/**
* @dev Returns the downcasted int136 from int256, reverting on
* overflow (when the input is less than smallest int136 or
* greater than largest int136).
*
* Counterpart to Solidity's `int136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*
* _Available since v4.7._
*/
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*
* _Available since v3.1._
*/
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
/**
* @dev Returns the downcasted int120 from int256, reverting on
* overflow (when the input is less than smallest int120 or
* greater than largest int120).
*
* Counterpart to Solidity's `int120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*
* _Available since v4.7._
*/
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
/**
* @dev Returns the downcasted int112 from int256, reverting on
* overflow (when the input is less than smallest int112 or
* greater than largest int112).
*
* Counterpart to Solidity's `int112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*
* _Available since v4.7._
*/
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
/**
* @dev Returns the downcasted int104 from int256, reverting on
* overflow (when the input is less than smallest int104 or
* greater than largest int104).
*
* Counterpart to Solidity's `int104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*
* _Available since v4.7._
*/
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
/**
* @dev Returns the downcasted int96 from int256, reverting on
* overflow (when the input is less than smallest int96 or
* greater than largest int96).
*
* Counterpart to Solidity's `int96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*
* _Available since v4.7._
*/
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
/**
* @dev Returns the downcasted int88 from int256, reverting on
* overflow (when the input is less than smallest int88 or
* greater than largest int88).
*
* Counterpart to Solidity's `int88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*
* _Available since v4.7._
*/
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
/**
* @dev Returns the downcasted int80 from int256, reverting on
* overflow (when the input is less than smallest int80 or
* greater than largest int80).
*
* Counterpart to Solidity's `int80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*
* _Available since v4.7._
*/
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
/**
* @dev Returns the downcasted int72 from int256, reverting on
* overflow (when the input is less than smallest int72 or
* greater than largest int72).
*
* Counterpart to Solidity's `int72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*
* _Available since v4.7._
*/
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*
* _Available since v3.1._
*/
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
/**
* @dev Returns the downcasted int56 from int256, reverting on
* overflow (when the input is less than smallest int56 or
* greater than largest int56).
*
* Counterpart to Solidity's `int56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*
* _Available since v4.7._
*/
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
/**
* @dev Returns the downcasted int48 from int256, reverting on
* overflow (when the input is less than smallest int48 or
* greater than largest int48).
*
* Counterpart to Solidity's `int48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*
* _Available since v4.7._
*/
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
/**
* @dev Returns the downcasted int40 from int256, reverting on
* overflow (when the input is less than smallest int40 or
* greater than largest int40).
*
* Counterpart to Solidity's `int40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*
* _Available since v4.7._
*/
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*
* _Available since v3.1._
*/
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
/**
* @dev Returns the downcasted int24 from int256, reverting on
* overflow (when the input is less than smallest int24 or
* greater than largest int24).
*
* Counterpart to Solidity's `int24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*
* _Available since v4.7._
*/
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*
* _Available since v3.1._
*/
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*
* _Available since v3.1._
*/
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*
* _Available since v3.0._
*/
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @notice Interface for functions the market uses in FETH.
* @author batu-inal & HardlyDifficult
*/
interface IFethMarket {
function depositFor(address account) external payable;
function marketLockupFor(address account, uint256 amount) external payable returns (uint256 expiration);
function marketWithdrawFrom(address from, uint256 amount) external;
function marketWithdrawLocked(address account, uint256 expiration, uint256 amount) external;
function marketUnlockFor(address account, uint256 expiration, uint256 amount) external;
function marketChangeLockup(
address unlockFrom,
uint256 unlockExpiration,
uint256 unlockAmount,
address lockupFor,
uint256 lockupAmount
) external payable returns (uint256 expiration);
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @title Declares the type of the collection contract.
* @dev This interface is declared as an ERC-165 interface.
* @author reggieag
*/
interface INFTCollectionType {
function getNFTCollectionType() external view returns (string memory collectionType);
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @title The required interface for collections to support minting from the NFTDropMarket.
* @dev This interface must be registered as a ERC165 supported interface.
* @author batu-inal & HardlyDifficult
*/
interface INFTLazyMintedCollectionMintCountTo {
function mintCountTo(uint16 count, address to) external returns (uint256 firstTokenId);
/**
* @notice Get the number of tokens which can still be minted.
* @return count The max number of additional NFTs that can be minted by this collection.
*/
function numberOfTokensAvailableToMint() external view returns (uint256 count);
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @notice The required interface for collections in the NFTDropMarket to support exhibitions.
* @author philbirt
*/
interface INFTMarketExhibition {
function isAllowedSellerForExhibition(
uint256 exhibitionId,
address seller
) external view returns (bool allowedSeller);
function getExhibitionPaymentDetails(
uint256 exhibitionId
) external view returns (address payable curator, uint16 takeRateInBasisPoints);
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @notice Interface for AdminRole which wraps the default admin role from
* OpenZeppelin's AccessControl for easy integration.
* @author batu-inal & HardlyDifficult
*/
interface IAdminRole {
function isAdmin(address account) external view returns (bool);
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @notice Interface for OperatorRole which wraps a role from
* OpenZeppelin's AccessControl for easy integration.
* @author batu-inal & HardlyDifficult
*/
interface IOperatorRole {
function isOperator(address account) external view returns (bool);
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @title Interface for routing calls to the NFT Drop Market to create fixed price sales.
* @author HardlyDifficult & reggieag
*/
interface INFTDropMarketFixedPriceSale {
function createFixedPriceSaleV3(
address nftContract,
uint256 exhibitionId,
uint256 price,
uint256 limitPerAccount,
uint256 generalAvailabilityStartTime,
uint256 txDeadlineTime
) external;
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @notice An interface for communicating fees to 3rd party marketplaces.
* @dev Originally implemented in mainnet contract 0x44d6e8933f8271abcf253c72f9ed7e0e4c0323b3
*/
interface IGetFees {
/**
* @notice Get the recipient addresses to which creator royalties should be sent.
* @dev The expected royalty amounts are communicated with `getFeeBps`.
* @param tokenId The ID of the NFT to get royalties for.
* @return recipients An array of addresses to which royalties should be sent.
*/
function getFeeRecipients(uint256 tokenId) external view returns (address payable[] memory recipients);
/**
* @notice Get the creator royalty amounts to be sent to each recipient, in basis points.
* @dev The expected recipients are communicated with `getFeeRecipients`.
* @param tokenId The ID of the NFT to get royalties for.
* @return royaltiesInBasisPoints The array of fees to be sent to each recipient, in basis points.
*/
function getFeeBps(uint256 tokenId) external view returns (uint256[] memory royaltiesInBasisPoints);
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
interface IGetRoyalties {
/**
* @notice Get the creator royalties to be sent.
* @dev The data is the same as when calling `getFeeRecipients` and `getFeeBps` separately.
* @param tokenId The ID of the NFT to get royalties for.
* @return recipients An array of addresses to which royalties should be sent.
* @return royaltiesInBasisPoints The array of fees to be sent to each recipient, in basis points.
*/
function getRoyalties(
uint256 tokenId
) external view returns (address payable[] memory recipients, uint256[] memory royaltiesInBasisPoints);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
interface IOwnable {
/**
* @dev Returns the address of the current owner.
*/
function owner() external view returns (address);
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @notice Interface for EIP-2981: NFT Royalty Standard.
* For more see: https://eips.ethereum.org/EIPS/eip-2981.
*/
interface IRoyaltyInfo {
/**
* @notice Get the creator royalties to be sent.
* @param tokenId The ID of the NFT to get royalties for.
* @param salePrice The total price of the sale.
* @return receiver The address to which royalties should be sent.
* @return royaltyAmount The total amount that should be sent to the `receiver`.
*/
function royaltyInfo(
uint256 tokenId,
uint256 salePrice
) external view returns (address receiver, uint256 royaltyAmount);
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
interface ITokenCreator {
/**
* @notice Returns the creator of this NFT collection.
* @param tokenId The ID of the NFT to get the creator payment address for.
* @return creator The creator of this collection.
*/
function tokenCreator(uint256 tokenId) external view returns (address payable creator);
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @title Helper functions for arrays.
* @author batu-inal & HardlyDifficult
*/
library ArrayLibrary {
/**
* @notice Reduces the size of an array if it's greater than the specified max size,
* using the first maxSize elements.
*/
function capLength(address payable[] memory data, uint256 maxLength) internal pure {
if (data.length > maxLength) {
assembly {
mstore(data, maxLength)
}
}
}
/**
* @notice Reduces the size of an array if it's greater than the specified max size,
* using the first maxSize elements.
*/
function capLength(uint256[] memory data, uint256 maxLength) internal pure {
if (data.length > maxLength) {
assembly {
mstore(data, maxLength)
}
}
}
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title Helper library for interacting with Merkle trees & proofs.
* @author batu-inal & HardlyDifficult & reggieag
*/
library MerkleAddressLibrary {
using MerkleProof for bytes32[];
/**
* @notice Gets the root for a merkle tree comprised only of addresses.
*/
function getMerkleRootForAddress(address user, bytes32[] calldata proof) internal pure returns (bytes32 root) {
bytes32 leaf = keccak256(abi.encodePacked(user));
root = proof.processProofCalldata(leaf);
}
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @title Helpers for working with time.
* @author batu-inal & HardlyDifficult
*/
library TimeLibrary {
/**
* @notice Checks if the given timestamp is in the past.
* @dev This helper ensures a consistent interpretation of expiry across the codebase.
* This is different than `hasBeenReached` in that it will return false if the expiry is now.
*/
function hasExpired(uint256 expiry) internal view returns (bool) {
return expiry < block.timestamp;
}
/**
* @notice Checks if the given timestamp is now or in the past.
* @dev This helper ensures a consistent interpretation of expiry across the codebase.
* This is different from `hasExpired` in that it will return true if the timestamp is now.
*/
function hasBeenReached(uint256 timestamp) internal view returns (bool) {
return timestamp <= block.timestamp;
}
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @title A place for common modifiers and functions used by various market mixins, if any.
* @dev This also leaves a gap which can be used to add a new mixin to the top of the inheritance tree.
* @author batu-inal & HardlyDifficult
*/
abstract contract NFTDropMarketCore {
/**
* @notice 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[1_000] private __gap;
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "../../interfaces/internal/INFTMarketExhibition.sol";
error NFTDropMarketExhibition_Exhibition_Does_Not_Exist();
error NFTDropMarketExhibition_NFT_Market_Is_Not_A_Contract();
error NFTDropMarketExhibition_Seller_Not_Allowed_In_Exhibition();
/**
* @title Enables a curation surface for sellers to exhibit their NFTs in the drop market.
* @author HardlyDifficult & philbirt
*/
abstract contract NFTDropMarketExhibition is Context {
using AddressUpgradeable for address;
/// @notice Maps a collection to the exhibition it was listed with.
mapping(address => uint256) private nftContractToExhibitionId;
/// @notice The NFT Market contract address, containing exhibition definitions.
address private immutable _nftMarket;
/**
* @notice Emitted when a collection is added to an exhibition.
* @param nftContract The contract address of the collection.
* @param exhibitionId The ID of the exhibition the collection was added to.
*/
event CollectionAddedToExhibition(address indexed nftContract, uint256 indexed exhibitionId);
/**
* @notice Set immutable variables for the implementation contract.
* @dev Using immutable instead of constants allows us to use different values on testnet.
* @param nftMarket The NFT Market contract address, containing exhibition definitions.
*/
constructor(address nftMarket) {
if (!nftMarket.isContract()) {
revert NFTDropMarketExhibition_NFT_Market_Is_Not_A_Contract();
}
_nftMarket = nftMarket;
}
/**
* @notice Adds a collection to an exhibition, if the ID provided is not 0.
*/
function _addCollectionToExhibition(address nftContract, uint256 exhibitionId) internal {
if (exhibitionId != 0) {
// If there is an exhibition, make sure the seller is allowed to list in it
if (
!INFTMarketExhibition(_nftMarket).isAllowedSellerForExhibition({
exhibitionId: exhibitionId,
seller: _msgSender()
})
) {
(address curator, ) = INFTMarketExhibition(_nftMarket).getExhibitionPaymentDetails(exhibitionId);
if (curator == address(0)) {
// Provides a more useful error when an exhibition never existed or has since been deleted.
revert NFTDropMarketExhibition_Exhibition_Does_Not_Exist();
}
revert NFTDropMarketExhibition_Seller_Not_Allowed_In_Exhibition();
}
nftContractToExhibitionId[nftContract] = exhibitionId;
emit CollectionAddedToExhibition(nftContract, exhibitionId);
}
}
/**
* @notice Returns the exhibition ID for a given Collection.
* @param nftContract The contract address of the Collection.
* @return exhibitionId The ID of the exhibition this Collection is assigned to, or 0 if it's
* not assigned to an exhibition.
*/
function getExhibitionIdForCollection(address nftContract) external view returns (uint256 exhibitionId) {
exhibitionId = nftContractToExhibitionId[nftContract];
}
/**
* @notice Returns the contract which contains the exhibition definitions.
* @return nftMarket The NFT Market contract address.
*/
function getNftMarket() external view returns (address nftMarket) {
nftMarket = _nftMarket;
}
/**
* @notice Returns the exhibition payment details for a given Collection.
* @dev The payment address and take rate will be 0 if the collection is not assigned to an exhibition or if the
* exhibition has seen been deleted.
*/
function _getExhibitionByCollection(
address nftContract
) internal view returns (address payable curator, uint16 takeRateInBasisPoints) {
uint256 exhibitionId = nftContractToExhibitionId[nftContract];
if (exhibitionId != 0) {
(curator, takeRateInBasisPoints) = INFTMarketExhibition(_nftMarket).getExhibitionPaymentDetails(exhibitionId);
}
}
/**
* @notice 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
* @dev This mixin uses 1,000 slots in total.
*/
uint256[999] private __gap;
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts/access/IAccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "../../interfaces/internal/INFTLazyMintedCollectionMintCountTo.sol";
import "../../interfaces/internal/routes/INFTDropMarketFixedPriceSale.sol";
import "../../libraries/MerkleAddressLibrary.sol";
import "../../libraries/TimeLibrary.sol";
import "../shared/Constants.sol";
import "../shared/MarketFees.sol";
import "../shared/TxDeadline.sol";
import "./NFTDropMarketExhibition.sol";
/// @param limitPerAccount The limit of tokens an account can purchase.
error NFTDropMarketFixedPriceSale_Cannot_Buy_More_Than_Limit(uint256 limitPerAccount);
/// @param earlyAccessStartTime The time when early access starts, in seconds since the Unix epoch.
error NFTDropMarketFixedPriceSale_Early_Access_Not_Open(uint256 earlyAccessStartTime);
error NFTDropMarketFixedPriceSale_Early_Access_Start_Time_Has_Expired();
error NFTDropMarketFixedPriceSale_General_Access_Is_Open();
/// @param generalAvailabilityStartTime The start time of the general availability period, in seconds since the Unix
/// epoch.
error NFTDropMarketFixedPriceSale_General_Access_Not_Open(uint256 generalAvailabilityStartTime);
error NFTDropMarketFixedPriceSale_General_Availability_Start_Time_Has_Expired();
error NFTDropMarketFixedPriceSale_Invalid_Merkle_Proof();
error NFTDropMarketFixedPriceSale_Invalid_Merkle_Root();
error NFTDropMarketFixedPriceSale_Invalid_Merkle_Tree_URI();
error NFTDropMarketFixedPriceSale_Limit_Per_Account_Must_Be_Set();
error NFTDropMarketFixedPriceSale_Mint_Permission_Required();
error NFTDropMarketFixedPriceSale_Must_Be_Listed_For_Sale();
error NFTDropMarketFixedPriceSale_Must_Buy_At_Least_One_Token();
error NFTDropMarketFixedPriceSale_Must_Have_Non_Zero_Early_Access_Duration();
error NFTDropMarketFixedPriceSale_Must_Not_Be_Sold_Out();
error NFTDropMarketFixedPriceSale_Must_Not_Have_Pending_Sale();
error NFTDropMarketFixedPriceSale_Must_Support_Collection_Mint_Interface();
error NFTDropMarketFixedPriceSale_Must_Support_ERC721();
error NFTDropMarketFixedPriceSale_Only_Callable_By_Collection_Owner();
error NFTDropMarketFixedPriceSale_Start_Time_Too_Far_In_The_Future();
/// @param mintCost The total cost for this purchase.
error NFTDropMarketFixedPriceSale_Too_Much_Value_Provided(uint256 mintCost);
/**
* @title Allows creators to list a drop collection for sale at a fixed price point.
* @dev Listing a collection for sale in this market requires the collection to implement
* the functions in `INFTLazyMintedCollectionMintCountTo` and to register that interface with ERC165.
* Additionally the collection must implement access control, or more specifically:
* `hasRole(bytes32(0), msg.sender)` must return true when called from the creator or admin's account
* and `hasRole(keccak256("MINTER_ROLE", address(this)))` must return true for this market's address.
* @author batu-inal & HardlyDifficult & philbirt & reggieag
*/
abstract contract NFTDropMarketFixedPriceSale is
INFTDropMarketFixedPriceSale,
TxDeadline,
MarketFees,
NFTDropMarketExhibition
{
using AddressUpgradeable for address;
using AddressUpgradeable for address payable;
using ERC165Checker for address;
using MerkleAddressLibrary for address;
using SafeCast for uint256;
using TimeLibrary for uint32;
using TimeLibrary for uint256;
/**
* @notice Configuration for the terms of the sale.
*/
struct FixedPriceSaleConfig {
/****** Slot 0 (of this struct) ******/
/// @notice The seller for the drop.
address payable seller;
/// @notice The fixed price per NFT in the collection.
/// @dev The maximum price that can be set on an NFT is ~1.2M (2^80/10^18) ETH.
uint80 price;
/// @notice The max number of NFTs an account may mint in this sale.
uint16 limitPerAccount;
/****** Slot 1 ******/
/// @notice Tracks how many NFTs a given user has already minted.
mapping(address => uint256) userToMintedCount;
/****** Slot 2 ******/
/// @notice The start time of the general availability period, in seconds since the Unix epoch.
/// @dev This must be >= `earlyAccessStartTime`.
/// When set to 0, general availability was not scheduled and started as soon as the price was set.
uint32 generalAvailabilityStartTime;
/// @notice The time when early access purchasing may begin, in seconds since the Unix epoch.
/// @dev This must be <= `generalAvailabilityStartTime`.
/// When set to 0, early access was not scheduled and started as soon as the price was set.
uint32 earlyAccessStartTime;
// 192-bits available in this slot
/****** Slot 3 ******/
/// @notice Merkle roots representing which users have access to purchase during the early access period.
/// @dev There may be many roots supported per sale where each is considered additive as any root may be used to
/// purchase.
mapping(bytes32 => bool) earlyAccessMerkleRoots;
}
/// @notice Stores the current sale information for all drop contracts.
mapping(address => FixedPriceSaleConfig) private nftContractToFixedPriceSaleConfig;
/**
* @dev Protocol fee for edition mints in basis points.
*/
uint256 private constant EDITION_PROTOCOL_FEE_IN_BASIS_POINTS = 500;
/**
* @notice Hash of the edition type name.
* @dev This is precalculated in order to save gas on use.
* `keccak256(abi.encodePacked(NFT_TIMED_EDITION_COLLECTION_TYPE))`
*/
bytes32 private constant editionTypeHash = 0xee2afa3f960e108aca17013728aafa363a0f4485661d9b6f41c6b4ddb55008ee;
/**
* @notice The `role` type used to validate drop collections have granted this market access to mint.
* @return `keccak256("MINTER_ROLE")`
*/
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
/**
* @notice Emitted when an early access merkle root is added to a fixed price sale early access period.
* @param nftContract The address of the NFT drop collection.
* @param merkleRoot The merkleRoot used to authorize early access purchases.
* @param merkleTreeUri The URI for the merkle tree represented by the merkleRoot.
*/
event AddMerkleRootToFixedPriceSale(address indexed nftContract, bytes32 merkleRoot, string merkleTreeUri);
/**
* @notice Emitted when a collection is listed for sale.
* @param nftContract The address of the NFT drop collection.
* @param seller The address for the seller which listed this for sale.
* @param price The price per NFT minted.
* @param limitPerAccount The max number of NFTs an account may mint in this sale.
* @param generalAvailabilityStartTime The time at which general purchases are available, in seconds since Unix epoch.
* Can not be more than two years from the creation block timestamp.
* @param earlyAccessStartTime The time at which early access purchases are available, in seconds since Unix epoch.
* Can not be more than two years from the creation block timestamp.
* @param merkleRoot The merkleRoot used to authorize early access purchases, or 0 if n/a.
* @param merkleTreeUri The URI for the merkle tree represented by the merkleRoot, or empty if n/a.
*/
event CreateFixedPriceSale(
address indexed nftContract,
address indexed seller,
uint256 price,
uint256 limitPerAccount,
uint256 generalAvailabilityStartTime,
uint256 earlyAccessStartTime,
bytes32 merkleRoot,
string merkleTreeUri
);
/**
* @notice Emitted when NFTs are minted from the drop.
* @dev The total price paid by the buyer is `totalFees + creatorRev`.
* @param nftContract The address of the NFT drop collection.
* @param buyer The address of the buyer.
* @param firstTokenId The tokenId for the first NFT minted.
* The other minted tokens are assigned sequentially, so `firstTokenId` - `firstTokenId + count - 1` were minted.
* @param count The number of NFTs minted.
* @param totalFees The amount of ETH that was sent to Foundation & referrals for this sale.
* @param creatorRev The amount of ETH that was sent to the creator for this sale.
*/
event MintFromFixedPriceDrop(
address indexed nftContract,
address indexed buyer,
uint256 indexed firstTokenId,
uint256 count,
uint256 totalFees,
uint256 creatorRev
);
/// @notice Requires the given NFT contract can mint at least 1 more NFT.
modifier notSoldOut(address nftContract) {
if (INFTLazyMintedCollectionMintCountTo(nftContract).numberOfTokensAvailableToMint() == 0) {
revert NFTDropMarketFixedPriceSale_Must_Not_Be_Sold_Out();
}
_;
}
/// @notice Requires the msg.sender has the admin role on the given NFT contract.
modifier onlyCollectionAdmin(address nftContract) {
if (!IAccessControl(nftContract).hasRole(DEFAULT_ADMIN_ROLE, _msgSender())) {
revert NFTDropMarketFixedPriceSale_Only_Callable_By_Collection_Owner();
}
_;
}
/// @notice Requires the given NFT contract supports the interfaces currently required by this market for minting,
/// and that it has granted this market the MINTER_ROLE.
modifier onlySupportedCollectionType(address nftContract) {
if (!nftContract.supportsInterface(type(INFTLazyMintedCollectionMintCountTo).interfaceId)) {
// Must support the mint interface this market depends on.
revert NFTDropMarketFixedPriceSale_Must_Support_Collection_Mint_Interface();
}
if (!nftContract.supportsERC165InterfaceUnchecked(type(IERC721).interfaceId)) {
// Must be an ERC-721 NFT collection.
revert NFTDropMarketFixedPriceSale_Must_Support_ERC721();
}
if (!IAccessControl(nftContract).hasRole(MINTER_ROLE, address(this))) {
revert NFTDropMarketFixedPriceSale_Mint_Permission_Required();
}
_;
}
/// @notice Requires the merkle params have been assigned non-zero values.
modifier onlyValidMerkle(bytes32 merkleRoot, string calldata merkleTreeUri) {
if (merkleRoot == bytes32(0)) {
revert NFTDropMarketFixedPriceSale_Invalid_Merkle_Root();
}
if (bytes(merkleTreeUri).length == 0) {
revert NFTDropMarketFixedPriceSale_Invalid_Merkle_Tree_URI();
}
_;
}
/// @notice Requires that the time provided is not more than 2 years in the future.
modifier onlyValidStartTime(uint256 startTime) {
if (startTime > block.timestamp + MAX_SCHEDULED_TIME_IN_THE_FUTURE) {
// Prevent arbitrarily large values from accidentally being set.
revert NFTDropMarketFixedPriceSale_Start_Time_Too_Far_In_The_Future();
}
_;
}
/**
* @notice Add a merkle root to an existing fixed price sale early access period.
* @param nftContract The address of the NFT drop collection.
* @param merkleRoot The merkleRoot used to authorize early access purchases.
* @param merkleTreeUri The URI for the merkle tree represented by the merkleRoot.
* @dev If you accidentally pass in the wrong merkleTreeUri for a merkleRoot,
* you can call this function again to emit a new event with a new merkleTreeUri.
*/
function addMerkleRootToFixedPriceSale(
address nftContract,
bytes32 merkleRoot,
string calldata merkleTreeUri
) external notSoldOut(nftContract) onlyCollectionAdmin(nftContract) onlyValidMerkle(merkleRoot, merkleTreeUri) {
FixedPriceSaleConfig storage saleConfig = nftContractToFixedPriceSaleConfig[nftContract];
if (saleConfig.generalAvailabilityStartTime.hasBeenReached()) {
// Start time may be 0, check if this collection has been listed to provide a better error message.
if (saleConfig.seller == payable(0)) {
revert NFTDropMarketFixedPriceSale_Must_Be_Listed_For_Sale();
}
// Adding users to the allow list is unnecessary when general access is open.
revert NFTDropMarketFixedPriceSale_General_Access_Is_Open();
}
if (saleConfig.generalAvailabilityStartTime == saleConfig.earlyAccessStartTime) {
// Must have non-zero early access duration, otherwise merkle roots are unnecessary.
revert NFTDropMarketFixedPriceSale_Must_Have_Non_Zero_Early_Access_Duration();
}
saleConfig.earlyAccessMerkleRoots[merkleRoot] = true;
emit AddMerkleRootToFixedPriceSale(nftContract, merkleRoot, merkleTreeUri);
}
/**
* @notice [DEPRECATED] use `createFixedPriceSaleV3` instead.
* Create a fixed price sale drop without an early access period.
* @param nftContract The address of the NFT drop collection.
* @param price The price per NFT minted.
* Set price to 0 for a first come first serve airdrop-like drop.
* @param limitPerAccount The max number of NFTs an account may mint in this sale.
* @dev Notes:
* a) The sale is final and can not be updated or canceled.
* b) The sale is immediately kicked off.
* c) Any collection that abides by `INFTLazyMintedCollectionMintCountTo` and `IAccessControl` is supported.
*/
function createFixedPriceSale(address nftContract, uint80 price, uint16 limitPerAccount) external {
_createFixedPriceSale({
nftContract: nftContract,
exhibitionId: 0,
price: price,
limitPerAccount: limitPerAccount,
generalAvailabilityStartTime: block.timestamp,
earlyAccessStartTime: block.timestamp,
merkleRoot: bytes32(0),
merkleTreeUri: ""
});
}
/**
* @notice [DEPRECATED] use `createFixedPriceSaleV3` instead.
* Create a fixed price sale drop without an early access period,
* optionally scheduling the sale to start sometime in the future.
* @param nftContract The address of the NFT drop collection.
* @param price The price per NFT minted.
* Set price to 0 for a first come first serve airdrop-like drop.
* @param limitPerAccount The max number of NFTs an account may mint in this sale.
* @param generalAvailabilityStartTime The time at which general purchases are available, in seconds since Unix epoch.
* Set this to 0 in order to have general availability begin as soon as the transaction is mined.
* Can not be more than two years from the creation block timestamp.
* @param txDeadlineTime The deadline timestamp for the transaction to be mined, in seconds since Unix epoch.
* Set this to 0 to send the transaction without a deadline.
* @dev Notes:
* a) The sale is final and can not be updated or canceled.
* b) Any collection that abides by `INFTLazyMintedCollectionMintCountTo` and `IAccessControl` is supported.
*/
function createFixedPriceSaleV2(
address nftContract,
uint256 price,
uint256 limitPerAccount,
uint256 generalAvailabilityStartTime,
uint256 txDeadlineTime
) external {
createFixedPriceSaleV3({
nftContract: nftContract,
exhibitionId: 0,
price: price,
limitPerAccount: limitPerAccount,
generalAvailabilityStartTime: generalAvailabilityStartTime,
txDeadlineTime: txDeadlineTime
});
}
/**
* @notice Create a fixed price sale drop without an early access period,
* optionally scheduling the sale to start sometime in the future.
* @param nftContract The address of the NFT drop collection.
* @param exhibitionId The exhibition to associate this fix priced sale to.
* Set this to 0 to exist outside of an exhibition.
* @param price The price per NFT minted.
* Set price to 0 for a first come first serve airdrop-like drop.
* @param limitPerAccount The max number of NFTs an account may mint in this sale.
* @param generalAvailabilityStartTime The time at which general purchases are available, in seconds since Unix epoch.
* Set this to 0 in order to have general availability begin as soon as the transaction is mined.
* Can not be more than two years from the creation block timestamp.
* @param txDeadlineTime The deadline timestamp for the transaction to be mined, in seconds since Unix epoch.
* Set this to 0 to send the transaction without a deadline.
* @dev Notes:
* a) The sale is final and can not be updated or canceled.
* b) Any collection that abides by `INFTLazyMintedCollectionMintCountTo` and `IAccessControl` is supported.
*/
function createFixedPriceSaleV3(
address nftContract,
uint256 exhibitionId,
uint256 price,
uint256 limitPerAccount,
uint256 generalAvailabilityStartTime,
uint256 txDeadlineTime
) public txDeadlineNotExpired(txDeadlineTime) {
// When generalAvailabilityStartTime is not specified, default to now.
if (generalAvailabilityStartTime == 0) {
generalAvailabilityStartTime = block.timestamp;
} else if (generalAvailabilityStartTime.hasExpired()) {
// The start time must be now or in the future.
revert NFTDropMarketFixedPriceSale_General_Availability_Start_Time_Has_Expired();
}
_createFixedPriceSale({
nftContract: nftContract,
exhibitionId: exhibitionId,
price: price,
limitPerAccount: limitPerAccount,
generalAvailabilityStartTime: generalAvailabilityStartTime,
earlyAccessStartTime: generalAvailabilityStartTime,
merkleRoot: bytes32(0),
merkleTreeUri: ""
});
}
/**
* @notice [DEPRECATED] use `createFixedPriceSaleWithEarlyAccessAllowlistV2` instead.
* Create a fixed price sale drop with an early access period.
* @param nftContract The address of the NFT drop collection.
* @param price The price per NFT minted.
* Set price to 0 for a first come first serve airdrop-like drop.
* @param limitPerAccount The max number of NFTs an account may mint in this sale.
* @param generalAvailabilityStartTime The time at which general purchases are available, in seconds since Unix epoch.
* This value must be > `earlyAccessStartTime`.
* @param earlyAccessStartTime The time at which early access purchases are available, in seconds since Unix epoch.
* Set this to 0 in order to have early access begin as soon as the transaction is mined.
* @param merkleRoot The merkleRoot used to authorize early access purchases.
* @param merkleTreeUri The URI for the merkle tree represented by the merkleRoot.
* @param txDeadlineTime The deadline timestamp for the transaction to be mined, in seconds since Unix epoch.
* Set this to 0 to send the transaction without a deadline.
* @dev Notes:
* a) The sale is final and can not be updated or canceled.
* b) Any collection that abides by `INFTLazyMintedCollectionMintCountTo` and `IAccessControl` is supported.
*/
function createFixedPriceSaleWithEarlyAccessAllowlist(
address nftContract,
uint256 price,
uint256 limitPerAccount,
uint256 generalAvailabilityStartTime,
uint256 earlyAccessStartTime,
bytes32 merkleRoot,
string calldata merkleTreeUri,
uint256 txDeadlineTime
) external {
createFixedPriceSaleWithEarlyAccessAllowlistV2({
nftContract: nftContract,
exhibitionId: 0,
price: price,
limitPerAccount: limitPerAccount,
generalAvailabilityStartTime: generalAvailabilityStartTime,
earlyAccessStartTime: earlyAccessStartTime,
merkleRoot: merkleRoot,
merkleTreeUri: merkleTreeUri,
txDeadlineTime: txDeadlineTime
});
}
/**
* @notice Create a fixed price sale drop with an early access period.
* @param nftContract The address of the NFT drop collection.
* @param exhibitionId The exhibition to associate this fix priced sale to.
* Set this to 0 to exist outside of an exhibition.
* @param price The price per NFT minted.
* Set price to 0 for a first come first serve airdrop-like drop.
* @param limitPerAccount The max number of NFTs an account may mint in this sale.
* @param generalAvailabilityStartTime The time at which general purchases are available, in seconds since Unix epoch.
* This value must be > `earlyAccessStartTime`.
* @param earlyAccessStartTime The time at which early access purchases are available, in seconds since Unix epoch.
* Set this to 0 in order to have early access begin as soon as the transaction is mined.
* @param merkleRoot The merkleRoot used to authorize early access purchases.
* @param merkleTreeUri The URI for the merkle tree represented by the merkleRoot.
* @param txDeadlineTime The deadline timestamp for the transaction to be mined, in seconds since Unix epoch.
* Set this to 0 to send the transaction without a deadline.
* @dev Notes:
* a) The sale is final and can not be updated or canceled.
* b) Any collection that abides by `INFTLazyMintedCollectionMintCountTo` and `IAccessControl` is supported.
*/
function createFixedPriceSaleWithEarlyAccessAllowlistV2(
address nftContract,
uint256 exhibitionId,
uint256 price,
uint256 limitPerAccount,
uint256 generalAvailabilityStartTime,
uint256 earlyAccessStartTime,
bytes32 merkleRoot,
string calldata merkleTreeUri,
uint256 txDeadlineTime
) public txDeadlineNotExpired(txDeadlineTime) onlyValidMerkle(merkleRoot, merkleTreeUri) {
// When earlyAccessStartTime is not specified, default to now.
if (earlyAccessStartTime == 0) {
earlyAccessStartTime = block.timestamp;
} else if (earlyAccessStartTime.hasExpired()) {
// The start time must be now or in the future.
revert NFTDropMarketFixedPriceSale_Early_Access_Start_Time_Has_Expired();
}
if (earlyAccessStartTime >= generalAvailabilityStartTime) {
// Early access period must start before GA period.
revert NFTDropMarketFixedPriceSale_Must_Have_Non_Zero_Early_Access_Duration();
}
_createFixedPriceSale(
nftContract,
exhibitionId,
price,
limitPerAccount,
generalAvailabilityStartTime,
earlyAccessStartTime,
merkleRoot,
merkleTreeUri
);
}
/**
* @notice Used to mint `count` number of NFTs from the collection during general availability.
* @param nftContract The address of the NFT drop collection.
* @param count The number of NFTs to mint.
* @param buyReferrer The address which referred this purchase, or address(0) if n/a.
* @return firstTokenId The tokenId for the first NFT minted.
* The other minted tokens are assigned sequentially, so `firstTokenId` - `firstTokenId + count - 1` were minted.
* @dev This call may revert if the collection has sold out, has an insufficient number of tokens available,
* or if the market's minter permissions were removed.
* If insufficient msg.value is included, the msg.sender's available FETH token balance will be used.
*/
function mintFromFixedPriceSale(
address nftContract,
uint16 count,
address payable buyReferrer
) external payable returns (uint256 firstTokenId) {
FixedPriceSaleConfig storage saleConfig = nftContractToFixedPriceSaleConfig[nftContract];
// Must be in general access period.
if (!saleConfig.generalAvailabilityStartTime.hasBeenReached()) {
revert NFTDropMarketFixedPriceSale_General_Access_Not_Open(saleConfig.generalAvailabilityStartTime);
}
firstTokenId = _mintFromFixedPriceSale(saleConfig, nftContract, count, buyReferrer);
}
/**
* @notice Used to mint `count` number of NFTs from the collection during early access.
* @param nftContract The address of the NFT drop collection.
* @param count The number of NFTs to mint.
* @param buyReferrer The address which referred this purchase, or address(0) if n/a.
* @param proof The merkle proof used to authorize this purchase.
* @return firstTokenId The tokenId for the first NFT minted.
* The other minted tokens are assigned sequentially, so `firstTokenId` - `firstTokenId + count - 1` were minted.
* @dev This call may revert if the collection has sold out, has an insufficient number of tokens available,
* or if the market's minter permissions were removed.
* If insufficient msg.value is included, the msg.sender's available FETH token balance will be used.
*/
function mintFromFixedPriceSaleWithEarlyAccessAllowlist(
address nftContract,
uint256 count,
address payable buyReferrer,
bytes32[] calldata proof
) external payable returns (uint256 firstTokenId) {
FixedPriceSaleConfig storage saleConfig = nftContractToFixedPriceSaleConfig[nftContract];
// Skip proof check if in general access period.
if (!saleConfig.generalAvailabilityStartTime.hasBeenReached()) {
// Must be in early access period or beyond.
if (!saleConfig.earlyAccessStartTime.hasBeenReached()) {
if (saleConfig.earlyAccessStartTime == saleConfig.generalAvailabilityStartTime) {
// This just provides a more targeted error message for the case where early access is not enabled.
revert NFTDropMarketFixedPriceSale_Must_Have_Non_Zero_Early_Access_Duration();
}
revert NFTDropMarketFixedPriceSale_Early_Access_Not_Open(saleConfig.earlyAccessStartTime);
}
bytes32 root = _msgSender().getMerkleRootForAddress(proof);
if (!saleConfig.earlyAccessMerkleRoots[root]) {
revert NFTDropMarketFixedPriceSale_Invalid_Merkle_Proof();
}
}
firstTokenId = _mintFromFixedPriceSale(saleConfig, nftContract, count, buyReferrer);
}
function _createFixedPriceSale(
address nftContract,
uint256 exhibitionId,
uint256 price,
uint256 limitPerAccount,
uint256 generalAvailabilityStartTime,
uint256 earlyAccessStartTime,
bytes32 merkleRoot,
string memory merkleTreeUri
)
private
onlySupportedCollectionType(nftContract)
notSoldOut(nftContract)
onlyCollectionAdmin(nftContract)
onlyValidStartTime(generalAvailabilityStartTime)
{
// Validate input params.
if (limitPerAccount == 0) {
// A non-zero limit is required.
revert NFTDropMarketFixedPriceSale_Limit_Per_Account_Must_Be_Set();
}
// Confirm this collection has not already been listed.
FixedPriceSaleConfig storage saleConfig = nftContractToFixedPriceSaleConfig[nftContract];
if (saleConfig.seller != payable(0)) {
revert NFTDropMarketFixedPriceSale_Must_Not_Have_Pending_Sale();
}
// Save the sale details.
address payable sender = payable(_msgSender());
saleConfig.seller = sender;
// Any price is supported, including 0.
saleConfig.price = price.toUint80();
saleConfig.limitPerAccount = limitPerAccount.toUint16();
if (generalAvailabilityStartTime != block.timestamp) {
// If starting now we don't need to write to storage
// Safe cast is not required since onlyValidStartTime confirms the max is within range.
saleConfig.generalAvailabilityStartTime = uint32(generalAvailabilityStartTime);
}
if (earlyAccessStartTime != block.timestamp) {
// If starting now we don't need to write to storage
// Safe cast is not required since callers require earlyAccessStartTime <= generalAvailabilityStartTime.
saleConfig.earlyAccessStartTime = uint32(earlyAccessStartTime);
}
// Store the merkle root if there's an early access period
if (merkleRoot != 0) {
saleConfig.earlyAccessMerkleRoots[merkleRoot] = true;
}
_addCollectionToExhibition(nftContract, exhibitionId);
emit CreateFixedPriceSale({
nftContract: nftContract,
seller: sender,
price: price,
limitPerAccount: limitPerAccount,
generalAvailabilityStartTime: generalAvailabilityStartTime,
earlyAccessStartTime: earlyAccessStartTime,
merkleRoot: merkleRoot,
merkleTreeUri: merkleTreeUri
});
}
function _mintFromFixedPriceSale(
FixedPriceSaleConfig storage saleConfig,
address nftContract,
uint256 count,
address payable buyReferrer
) private returns (uint256 firstTokenId) {
// Validate input params.
if (count == 0) {
revert NFTDropMarketFixedPriceSale_Must_Buy_At_Least_One_Token();
}
// Confirm that the buyer will not exceed the limit specified after minting.
address sender = _msgSender();
uint256 minted = saleConfig.userToMintedCount[sender] + count;
if (minted > saleConfig.limitPerAccount) {
if (saleConfig.limitPerAccount == 0) {
// Provide a more targeted error if the collection has not been listed.
revert NFTDropMarketFixedPriceSale_Must_Be_Listed_For_Sale();
}
revert NFTDropMarketFixedPriceSale_Cannot_Buy_More_Than_Limit(saleConfig.limitPerAccount);
}
saleConfig.userToMintedCount[sender] = minted;
// Calculate the total cost, considering the `count` requested.
uint256 mintCost;
unchecked {
// Can not overflow as 2^80 * 2^16 == 2^96 max which fits in 256 bits.
mintCost = uint256(saleConfig.price) * count;
}
// The sale price is immutable so the buyer is aware of how much they will be paying when their tx is broadcasted.
if (msg.value > mintCost) {
// Since price is known ahead of time, if too much ETH is sent then something went wrong.
revert NFTDropMarketFixedPriceSale_Too_Much_Value_Provided(mintCost);
}
// Withdraw from the user's available FETH balance if insufficient msg.value was included.
_tryUseFETHBalance({ totalAmount: mintCost, shouldRefundSurplus: false });
// Mint the NFTs.
// Safe cast is not required, above confirms count <= limitPerAccount which is uint16.
firstTokenId = INFTLazyMintedCollectionMintCountTo(nftContract).mintCountTo(uint16(count), sender);
(address payable curator, uint16 takeRateInBasisPoints) = _getExhibitionByCollection(nftContract);
// Distribute revenue from this sale.
(uint256 totalFees, uint256 creatorRev, ) = _distributeFunds({
nftContract: nftContract,
tokenId: firstTokenId,
seller: saleConfig.seller,
price: mintCost,
buyReferrer: buyReferrer,
sellerReferrerPaymentAddress: curator,
sellerReferrerTakeRateInBasisPoints: takeRateInBasisPoints
});
emit MintFromFixedPriceDrop({
nftContract: nftContract,
buyer: sender,
firstTokenId: firstTokenId,
count: count,
totalFees: totalFees,
creatorRev: creatorRev
});
}
/**
* @notice Returns the max number of NFTs a given account may mint.
* @param nftContract The address of the NFT drop collection.
* @param user The address of the user which will be minting.
* @return numberThatCanBeMinted How many NFTs the user can mint.
*/
function getAvailableCountFromFixedPriceSale(
address nftContract,
address user
) external view returns (uint256 numberThatCanBeMinted) {
(, , uint256 limitPerAccount, uint256 numberOfTokensAvailableToMint, bool marketCanMint, , ) = getFixedPriceSale(
nftContract
);
if (!marketCanMint) {
// No one can mint in the current state.
return 0;
}
uint256 mintedCount = nftContractToFixedPriceSaleConfig[nftContract].userToMintedCount[user];
if (mintedCount >= limitPerAccount) {
// User has exhausted their limit.
return 0;
}
unchecked {
// Safe math is not required due to the if statement directly above.
numberThatCanBeMinted = limitPerAccount - mintedCount;
}
if (numberThatCanBeMinted > numberOfTokensAvailableToMint) {
// User has more tokens available than the collection has available.
numberThatCanBeMinted = numberOfTokensAvailableToMint;
}
}
/**
* @notice Returns details for a drop collection's fixed price sale.
* @param nftContract The address of the NFT drop collection.
* @return seller The address of the seller which listed this drop for sale.
* This value will be address(0) if the collection is not listed or has sold out.
* @return price The price per NFT minted.
* @return limitPerAccount The max number of NFTs an account may mint in this sale.
* @return numberOfTokensAvailableToMint The number of NFTs available to mint.
* @return marketCanMint True if this contract has permissions to mint from the given collection.
* @return generalAvailabilityStartTime The time at which general availability starts.
* When set to 0, general availability was not scheduled and started as soon as the price was set.
* @return earlyAccessStartTime The timestamp at which the allowlist period starts.
* When set to 0, early access was not scheduled and started as soon as the price was set.
*/
function getFixedPriceSale(
address nftContract
)
public
view
returns (
address payable seller,
uint256 price,
uint256 limitPerAccount,
uint256 numberOfTokensAvailableToMint,
bool marketCanMint,
uint256 generalAvailabilityStartTime,
uint256 earlyAccessStartTime
)
{
try INFTLazyMintedCollectionMintCountTo(nftContract).numberOfTokensAvailableToMint() returns (uint256 count) {
if (count != 0) {
try IAccessControl(nftContract).hasRole(MINTER_ROLE, address(this)) returns (bool hasRole) {
FixedPriceSaleConfig storage saleConfig = nftContractToFixedPriceSaleConfig[nftContract];
seller = saleConfig.seller;
price = saleConfig.price;
limitPerAccount = saleConfig.limitPerAccount;
numberOfTokensAvailableToMint = count;
marketCanMint = hasRole;
earlyAccessStartTime = saleConfig.earlyAccessStartTime;
generalAvailabilityStartTime = saleConfig.generalAvailabilityStartTime;
} catch {
// The contract is not supported - return default values.
}
}
// Else minted completed -- return default values.
} catch {
// Contract not supported or self destructed - return default values
}
}
/**
* @notice Checks if a given merkle root has been authorized to purchase from a given drop collection.
* @param nftContract The address of the NFT drop collection.
* @param merkleRoot The merkle root to check.
* @return supported True if the merkle root has been authorized.
*/
function getFixedPriceSaleEarlyAccessAllowlistSupported(
address nftContract,
bytes32 merkleRoot
) external view returns (bool supported) {
supported = nftContractToFixedPriceSaleConfig[nftContract].earlyAccessMerkleRoots[merkleRoot];
}
/**
* @inheritdoc MarketFees
* @dev Offers a reduced protocol fee for NFT edition collection sales.
*/
function _getProtocolFee(
address nftContract
) internal view virtual override returns (uint256 protocolFeeInBasisPoints) {
try INFTCollectionType(nftContract).getNFTCollectionType() returns (string memory nftCollectionType) {
if (keccak256(abi.encodePacked(nftCollectionType)) == editionTypeHash) {
return EDITION_PROTOCOL_FEE_IN_BASIS_POINTS;
}
} catch {
// Fall through to use the default fee of 15% instead.
// If the collection implements a fallback function, decoding will revert and cause the sale to fail.
}
return super._getProtocolFee(nftContract);
}
/**
* @inheritdoc MarketSharedCore
* @dev Returns the seller for a collection if listed and not already sold out.
*/
function _getSellerOf(
address nftContract,
uint256 /* tokenId */
) internal view virtual override returns (address payable seller) {
(seller, , , , , , ) = getFixedPriceSale(nftContract);
}
/**
* @notice 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[1_000] private __gap;
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/// Constant values shared across mixins.
/**
* @dev 100% in basis points.
*/
uint256 constant BASIS_POINTS = 10_000;
/**
* @dev The default admin role defined by OZ ACL modules.
*/
bytes32 constant DEFAULT_ADMIN_ROLE = 0x00;
////////////////////////////////////////////////////////////////
// Royalties & Take Rates
////////////////////////////////////////////////////////////////
/**
* @dev The max take rate an exhibition can have.
*/
uint256 constant MAX_EXHIBITION_TAKE_RATE = 5_000;
/**
* @dev Cap the number of royalty recipients.
* A cap is required to ensure gas costs are not too high when a sale is settled.
*/
uint256 constant MAX_ROYALTY_RECIPIENTS = 5;
/**
* @dev Default royalty cut paid out on secondary sales.
* Set to 10% of the secondary sale.
*/
uint96 constant ROYALTY_IN_BASIS_POINTS = 1_000;
/**
* @dev 10%, expressed as a denominator for more efficient calculations.
*/
uint256 constant ROYALTY_RATIO = BASIS_POINTS / ROYALTY_IN_BASIS_POINTS;
////////////////////////////////////////////////////////////////
// Gas Limits
////////////////////////////////////////////////////////////////
/**
* @dev The gas limit used when making external read-only calls.
* This helps to ensure that external calls does not prevent the market from executing.
*/
uint256 constant READ_ONLY_GAS_LIMIT = 40_000;
/**
* @dev The gas limit to send ETH to multiple recipients, enough for a 5-way split.
*/
uint256 constant SEND_VALUE_GAS_LIMIT_MULTIPLE_RECIPIENTS = 210_000;
/**
* @dev The gas limit to send ETH to a single recipient, enough for a contract with a simple receiver.
*/
uint256 constant SEND_VALUE_GAS_LIMIT_SINGLE_RECIPIENT = 20_000;
////////////////////////////////////////////////////////////////
// Collection Type Names
////////////////////////////////////////////////////////////////
/**
* @dev The NFT collection type.
*/
string constant NFT_COLLECTION_TYPE = "NFT Collection";
/**
* @dev The NFT drop collection type.
*/
string constant NFT_DROP_COLLECTION_TYPE = "NFT Drop Collection";
/**
* @dev The NFT edition collection type.
*/
string constant NFT_TIMED_EDITION_COLLECTION_TYPE = "NFT Timed Edition Collection";
////////////////////////////////////////////////////////////////
// Business Logic
////////////////////////////////////////////////////////////////
/**
* @dev Limits scheduled start/end times to be less than 2 years in the future.
*/
uint256 constant MAX_SCHEDULED_TIME_IN_THE_FUTURE = 365 days * 2;
/**
* @dev The minimum increase of 10% required when making an offer or placing a bid.
*/
uint256 constant MIN_PERCENT_INCREMENT_DENOMINATOR = BASIS_POINTS / 1_000;
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "../../interfaces/internal/IFethMarket.sol";
error FETHNode_FETH_Address_Is_Not_A_Contract();
error FETHNode_Only_FETH_Can_Transfer_ETH();
/**
* @title A mixin for interacting with the FETH contract.
* @author batu-inal & HardlyDifficult
*/
abstract contract FETHNode is Context {
using AddressUpgradeable for address;
using AddressUpgradeable for address payable;
/// @notice The FETH ERC-20 token for managing escrow and lockup.
IFethMarket internal immutable feth;
constructor(address _feth) {
if (!_feth.isContract()) {
revert FETHNode_FETH_Address_Is_Not_A_Contract();
}
feth = IFethMarket(_feth);
}
/**
* @notice Only used by FETH. Any direct transfer from users will revert.
*/
receive() external payable {
if (msg.sender != address(feth)) {
revert FETHNode_Only_FETH_Can_Transfer_ETH();
}
}
/**
* @notice Withdraw the msg.sender's available FETH balance if they requested more than the msg.value provided.
* @dev This may revert if the msg.sender is non-receivable.
* This helper should not be used anywhere that may lead to locked assets.
* @param totalAmount The total amount of ETH required (including the msg.value).
* @param shouldRefundSurplus If true, refund msg.value - totalAmount to the msg.sender.
*/
function _tryUseFETHBalance(uint256 totalAmount, bool shouldRefundSurplus) internal {
if (totalAmount > msg.value) {
// Withdraw additional ETH required from the user's available FETH balance.
unchecked {
// The if above ensures delta will not underflow.
// Withdraw ETH from the user's account in the FETH token contract,
// making the funds available in this contract as ETH.
feth.marketWithdrawFrom(_msgSender(), totalAmount - msg.value);
}
} else if (shouldRefundSurplus && totalAmount < msg.value) {
// Return any surplus ETH to the user.
unchecked {
// The if above ensures this will not underflow
payable(_msgSender()).sendValue(msg.value - totalAmount);
}
}
}
/**
* @notice Gets the FETH contract used to escrow offer funds.
* @return fethAddress The FETH contract address.
*/
function getFethAddress() external view returns (address fethAddress) {
fethAddress = address(feth);
}
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "../../interfaces/internal/roles/IAdminRole.sol";
import "../../interfaces/internal/roles/IOperatorRole.sol";
error FoundationTreasuryNode_Address_Is_Not_A_Contract();
error FoundationTreasuryNode_Caller_Not_Admin();
error FoundationTreasuryNode_Caller_Not_Operator();
/**
* @title A mixin that stores a reference to the Foundation treasury contract.
* @notice The treasury collects fees and defines admin/operator roles.
* @author batu-inal & HardlyDifficult
*/
abstract contract FoundationTreasuryNode {
using AddressUpgradeable for address payable;
/// @dev This value was replaced with an immutable version.
address payable private __gap_was_treasury;
/// @notice The address of the treasury contract.
address payable private immutable treasury;
/// @notice Requires the caller is a Foundation admin.
modifier onlyFoundationAdmin() {
if (!IAdminRole(treasury).isAdmin(msg.sender)) {
revert FoundationTreasuryNode_Caller_Not_Admin();
}
_;
}
/// @notice Requires the caller is a Foundation operator.
modifier onlyFoundationOperator() {
if (!IOperatorRole(treasury).isOperator(msg.sender)) {
revert FoundationTreasuryNode_Caller_Not_Operator();
}
_;
}
/**
* @notice Set immutable variables for the implementation contract.
* @dev Assigns the treasury contract address.
*/
constructor(address payable _treasury) {
if (!_treasury.isContract()) {
revert FoundationTreasuryNode_Address_Is_Not_A_Contract();
}
treasury = _treasury;
}
/**
* @notice Gets the Foundation treasury contract.
* @dev This call is used in the royalty registry contract.
* @return treasuryAddress The address of the Foundation treasury contract.
*/
function getFoundationTreasury() public view returns (address payable treasuryAddress) {
treasuryAddress = treasury;
}
/**
* @notice 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[2_000] private __gap;
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @title A placeholder contract leaving room for new mixins to be added to the future.
* @author HardlyDifficult
*/
abstract contract Gap500 {
/**
* @notice 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[500] private __gap;
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
/**
* @title A placeholder contract leaving room for new mixins to be added to the future.
* @author HardlyDifficult
*/
abstract contract Gap9000 {
/**
* @notice 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[9_000] private __gap;
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import "@manifoldxyz/royalty-registry-solidity/contracts/IRoyaltyRegistry.sol";
import "../../interfaces/internal/INFTCollectionType.sol";
import "../../interfaces/standards/royalties/IGetFees.sol";
import "../../interfaces/standards/royalties/IGetRoyalties.sol";
import "../../interfaces/standards/royalties/IOwnable.sol";
import "../../interfaces/standards/royalties/IRoyaltyInfo.sol";
import "../../interfaces/standards/royalties/ITokenCreator.sol";
import "../../libraries/ArrayLibrary.sol";
import "./Constants.sol";
import "./FoundationTreasuryNode.sol";
import "./SendValueWithFallbackWithdraw.sol";
import "./MarketSharedCore.sol";
error NFTMarketFees_Royalty_Registry_Is_Not_A_Contract();
error NFTMarketFees_Invalid_Protocol_Fee();
/**
* @title A mixin to distribute funds when an NFT is sold.
* @author batu-inal & HardlyDifficult
*/
abstract contract MarketFees is FoundationTreasuryNode, Context, MarketSharedCore, SendValueWithFallbackWithdraw {
using AddressUpgradeable for address;
using ArrayLibrary for address payable[];
using ArrayLibrary for uint256[];
using ERC165Checker for address;
/**
* @dev Removing old unused variables in an upgrade safe way. Was:
* uint256 private _primaryFoundationFeeBasisPoints;
* uint256 private _secondaryFoundationFeeBasisPoints;
* uint256 private _secondaryCreatorFeeBasisPoints;
* mapping(address => mapping(uint256 => bool)) private _nftContractToTokenIdToFirstSaleCompleted;
*/
uint256[4] private __gap_was_fees;
/// @notice The royalties sent to creator recipients on secondary sales.
uint256 private constant CREATOR_ROYALTY_DENOMINATOR = BASIS_POINTS / 1_000; // 10%
/// @notice The fee collected by Foundation for sales facilitated by this market contract.
uint256 private immutable DEFAULT_PROTOCOL_FEE_IN_BASIS_POINTS;
/// @notice The fee collected by the buy referrer for sales facilitated by this market contract.
/// This fee is calculated from the total protocol fee.
uint256 private constant BUY_REFERRER_FEE_DENOMINATOR = BASIS_POINTS / 100; // 1%
/// @notice The address of the royalty registry which may be used to define royalty overrides for some collections.
IRoyaltyRegistry private immutable royaltyRegistry;
/// @notice The address of this contract's implementation.
/// @dev This is used when making stateless external calls to this contract,
/// saving gas over hopping through the proxy which is only necessary when accessing state.
MarketFees private immutable implementationAddress;
/// @notice True for the Drop market which only performs primary sales. False if primary & secondary are supported.
bool private immutable assumePrimarySale;
/**
* @notice Emitted when an NFT sold with a referrer.
* @param nftContract The address of the NFT contract.
* @param tokenId The id of the NFT.
* @param buyReferrer The account which received the buy referral incentive.
* @param buyReferrerFee The portion of the protocol fee collected by the buy referrer.
* @param buyReferrerSellerFee The portion of the owner revenue collected by the buy referrer (not implemented).
*/
event BuyReferralPaid(
address indexed nftContract,
uint256 indexed tokenId,
address buyReferrer,
uint256 buyReferrerFee,
uint256 buyReferrerSellerFee
);
/**
* @notice Emitted when an NFT is sold when associated with a sell referrer.
* @param nftContract The address of the NFT contract.
* @param tokenId The id of the NFT.
* @param sellerReferrer The account which received the sell referral incentive.
* @param sellerReferrerFee The portion of the seller revenue collected by the sell referrer.
*/
event SellerReferralPaid(
address indexed nftContract,
uint256 indexed tokenId,
address sellerReferrer,
uint256 sellerReferrerFee
);
/**
* @notice Configures the registry allowing for royalty overrides to be defined.
* @param _royaltyRegistry The registry to use for royalty overrides.
* @param _assumePrimarySale True for the Drop market which only performs primary sales.
* False if primary & secondary are supported.
*/
constructor(uint16 protocolFeeInBasisPoints, address _royaltyRegistry, bool _assumePrimarySale) {
if (
protocolFeeInBasisPoints < BASIS_POINTS / BUY_REFERRER_FEE_DENOMINATOR ||
protocolFeeInBasisPoints + BASIS_POINTS / CREATOR_ROYALTY_DENOMINATOR >= BASIS_POINTS - MAX_EXHIBITION_TAKE_RATE
) {
/* If the protocol fee is invalid, revert:
* Protocol fee must be greater than the buy referrer fee since referrer fees are deducted from the protocol fee.
* The protocol fee must leave room for the creator royalties and the max exhibition take rate.
*/
revert NFTMarketFees_Invalid_Protocol_Fee();
}
DEFAULT_PROTOCOL_FEE_IN_BASIS_POINTS = protocolFeeInBasisPoints;
if (!_royaltyRegistry.isContract()) {
// Not using a 165 check since mainnet and goerli are not using the same versions of the registry.
revert NFTMarketFees_Royalty_Registry_Is_Not_A_Contract();
}
royaltyRegistry = IRoyaltyRegistry(_royaltyRegistry);
assumePrimarySale = _assumePrimarySale;
// In the constructor, `this` refers to the implementation address. Everywhere else it'll be the proxy.
implementationAddress = this;
}
/**
* @notice Distributes funds to foundation, creator recipients, and NFT owner after a sale.
*/
function _distributeFunds(
address nftContract,
uint256 tokenId,
address payable seller,
uint256 price,
address payable buyReferrer,
address payable sellerReferrerPaymentAddress,
uint16 sellerReferrerTakeRateInBasisPoints
) internal returns (uint256 totalFees, uint256 creatorRev, uint256 sellerRev) {
if (price == 0) {
// When the sale price is 0, there are no revenue to distribute.
return (0, 0, 0);
}
address payable[] memory creatorRecipients;
uint256[] memory creatorShares;
uint256 buyReferrerFee;
uint256 sellerReferrerFee;
(totalFees, creatorRecipients, creatorShares, sellerRev, buyReferrerFee, sellerReferrerFee) = _getFees(
nftContract,
tokenId,
seller,
price,
buyReferrer,
sellerReferrerTakeRateInBasisPoints
);
// Pay the creator(s)
// If just a single recipient was defined, use a larger gas limit in order to support in-contract split logic.
uint256 creatorGasLimit = creatorRecipients.length == 1
? SEND_VALUE_GAS_LIMIT_MULTIPLE_RECIPIENTS
: SEND_VALUE_GAS_LIMIT_SINGLE_RECIPIENT;
unchecked {
for (uint256 i = 0; i < creatorRecipients.length; ++i) {
_sendValueWithFallbackWithdraw(creatorRecipients[i], creatorShares[i], creatorGasLimit);
// Sum the total creator rev from shares
// creatorShares is in ETH so creatorRev will not overflow here.
creatorRev += creatorShares[i];
}
}
// Pay the seller
_sendValueWithFallbackWithdraw(seller, sellerRev, SEND_VALUE_GAS_LIMIT_SINGLE_RECIPIENT);
// Pay the protocol fee
_sendValueWithFallbackWithdraw(getFoundationTreasury(), totalFees, SEND_VALUE_GAS_LIMIT_SINGLE_RECIPIENT);
// Pay the buy referrer fee
if (buyReferrerFee != 0) {
_sendValueWithFallbackWithdraw(buyReferrer, buyReferrerFee, SEND_VALUE_GAS_LIMIT_SINGLE_RECIPIENT);
emit BuyReferralPaid({
nftContract: nftContract,
tokenId: tokenId,
buyReferrer: buyReferrer,
buyReferrerFee: buyReferrerFee,
buyReferrerSellerFee: 0
});
unchecked {
// Add the referrer fee back into the total fees so that all 3 return fields sum to the total price for events
totalFees += buyReferrerFee;
}
}
if (sellerReferrerPaymentAddress != address(0)) {
if (sellerReferrerFee != 0) {
// Add the seller referrer fee back to revenue so that all 3 return fields sum to the total price for events.
unchecked {
if (sellerRev == 0) {
// When sellerRev is 0, this is a primary sale and all revenue is attributed to the "creator".
creatorRev += sellerReferrerFee;
} else {
sellerRev += sellerReferrerFee;
}
}
_sendValueWithFallbackWithdraw(
sellerReferrerPaymentAddress,
sellerReferrerFee,
SEND_VALUE_GAS_LIMIT_SINGLE_RECIPIENT
);
}
emit SellerReferralPaid(nftContract, tokenId, sellerReferrerPaymentAddress, sellerReferrerFee);
}
}
/**
* @notice Returns how funds will be distributed for a sale at the given price point.
* @param nftContract The address of the NFT contract.
* @param tokenId The id of the NFT.
* @param price The sale price to calculate the fees for.
* @return totalFees How much will be sent to the Foundation treasury and/or referrals.
* @return creatorRev How much will be sent across all the `creatorRecipients` defined.
* @return creatorRecipients The addresses of the recipients to receive a portion of the creator fee.
* @return creatorShares The percentage of the creator fee to be distributed to each `creatorRecipient`.
* If there is only one `creatorRecipient`, this may be an empty array.
* Otherwise `creatorShares.length` == `creatorRecipients.length`.
* @return sellerRev How much will be sent to the owner/seller of the NFT.
* If the NFT is being sold by the creator, this may be 0 and the full revenue will appear as `creatorRev`.
* @return seller The address of the owner of the NFT.
* If `sellerRev` is 0, this may be `address(0)`.
*/
function getFeesAndRecipients(
address nftContract,
uint256 tokenId,
uint256 price
)
external
view
returns (
uint256 totalFees,
uint256 creatorRev,
address payable[] memory creatorRecipients,
uint256[] memory creatorShares,
uint256 sellerRev,
address payable seller
)
{
seller = _getSellerOrOwnerOf(nftContract, tokenId);
(totalFees, creatorRecipients, creatorShares, sellerRev, , ) = _getFees({
nftContract: nftContract,
tokenId: tokenId,
seller: seller,
price: price,
// Notice: Setting this value is a breaking change for the FNDMiddleware contract.
// Will be wired in an upcoming release to communicate the buy referral information.
buyReferrer: payable(0),
sellerReferrerTakeRateInBasisPoints: 0
});
// Sum the total creator rev from shares
unchecked {
for (uint256 i = 0; i < creatorShares.length; ++i) {
creatorRev += creatorShares[i];
}
}
}
/**
* @notice Returns the address of the registry allowing for royalty configuration overrides.
* @dev See https://royaltyregistry.xyz/
* @return registry The address of the royalty registry contract.
*/
function getRoyaltyRegistry() external view returns (address registry) {
registry = address(royaltyRegistry);
}
/**
* @notice **For internal use only.**
* @dev This function is external to allow using try/catch but is not intended for external use.
* This checks the token creator.
*/
function internalGetTokenCreator(
address nftContract,
uint256 tokenId
) external view returns (address payable creator) {
creator = ITokenCreator(nftContract).tokenCreator{ gas: READ_ONLY_GAS_LIMIT }(tokenId);
}
/**
* @notice **For internal use only.**
* @dev This function is external to allow using try/catch but is not intended for external use.
* If ERC2981 royalties (or getRoyalties) are defined by the NFT contract, allow this standard to define immutable
* royalties that cannot be later changed via the royalty registry.
*/
function internalGetImmutableRoyalties(
address nftContract,
uint256 tokenId
) external view returns (address payable[] memory recipients, uint256[] memory splitPerRecipientInBasisPoints) {
// 1st priority: ERC-2981
if (nftContract.supportsERC165InterfaceUnchecked(type(IRoyaltyInfo).interfaceId)) {
try IRoyaltyInfo(nftContract).royaltyInfo{ gas: READ_ONLY_GAS_LIMIT }(tokenId, BASIS_POINTS) returns (
address receiver,
uint256 royaltyAmount
) {
// Manifold contracts return (address(this), 0) when royalties are not defined
// - so ignore results when the amount is 0
if (royaltyAmount > 0) {
recipients = new address payable[](1);
recipients[0] = payable(receiver);
splitPerRecipientInBasisPoints = new uint256[](1);
// The split amount is assumed to be 100% when only 1 recipient is returned
return (recipients, splitPerRecipientInBasisPoints);
}
} catch {
// Fall through
}
}
// 2nd priority: getRoyalties
if (nftContract.supportsERC165InterfaceUnchecked(type(IGetRoyalties).interfaceId)) {
try IGetRoyalties(nftContract).getRoyalties{ gas: READ_ONLY_GAS_LIMIT }(tokenId) returns (
address payable[] memory _recipients,
uint256[] memory recipientBasisPoints
) {
if (_recipients.length != 0 && _recipients.length == recipientBasisPoints.length) {
return (_recipients, recipientBasisPoints);
}
} catch {
// Fall through
}
}
}
/**
* @notice **For internal use only.**
* @dev This function is external to allow using try/catch but is not intended for external use.
* This checks for royalties defined in the royalty registry or via a non-standard royalty API.
*/
function internalGetMutableRoyalties(
address nftContract,
uint256 tokenId,
address payable creator
) external view returns (address payable[] memory recipients, uint256[] memory splitPerRecipientInBasisPoints) {
/* Overrides must support ERC-165 when registered, except for overrides defined by the registry owner.
If that results in an override w/o 165 we may need to upgrade the market to support or ignore that override. */
// The registry requires overrides are not 0 and contracts when set.
// If no override is set, the nftContract address is returned.
try royaltyRegistry.getRoyaltyLookupAddress{ gas: READ_ONLY_GAS_LIMIT }(nftContract) returns (
address overrideContract
) {
if (overrideContract != nftContract) {
nftContract = overrideContract;
// The functions above are repeated here if an override is set.
// 3rd priority: ERC-2981 override
if (nftContract.supportsERC165InterfaceUnchecked(type(IRoyaltyInfo).interfaceId)) {
try IRoyaltyInfo(nftContract).royaltyInfo{ gas: READ_ONLY_GAS_LIMIT }(tokenId, BASIS_POINTS) returns (
address receiver,
uint256 royaltyAmount
) {
// Manifold contracts return (address(this), 0) when royalties are not defined
// - so ignore results when the amount is 0
if (royaltyAmount != 0) {
recipients = new address payable[](1);
recipients[0] = payable(receiver);
splitPerRecipientInBasisPoints = new uint256[](1);
// The split amount is assumed to be 100% when only 1 recipient is returned
return (recipients, splitPerRecipientInBasisPoints);
}
} catch {
// Fall through
}
}
// 4th priority: getRoyalties override
if (recipients.length == 0 && nftContract.supportsERC165InterfaceUnchecked(type(IGetRoyalties).interfaceId)) {
try IGetRoyalties(nftContract).getRoyalties{ gas: READ_ONLY_GAS_LIMIT }(tokenId) returns (
address payable[] memory _recipients,
uint256[] memory recipientBasisPoints
) {
if (_recipients.length != 0 && _recipients.length == recipientBasisPoints.length) {
return (_recipients, recipientBasisPoints);
}
} catch {
// Fall through
}
}
}
} catch {
// Ignore out of gas errors and continue using the nftContract address
}
// 5th priority: getFee* from contract or override
if (nftContract.supportsERC165InterfaceUnchecked(type(IGetFees).interfaceId)) {
try IGetFees(nftContract).getFeeRecipients{ gas: READ_ONLY_GAS_LIMIT }(tokenId) returns (
address payable[] memory _recipients
) {
if (_recipients.length != 0) {
try IGetFees(nftContract).getFeeBps{ gas: READ_ONLY_GAS_LIMIT }(tokenId) returns (
uint256[] memory recipientBasisPoints
) {
if (_recipients.length == recipientBasisPoints.length) {
return (_recipients, recipientBasisPoints);
}
} catch {
// Fall through
}
}
} catch {
// Fall through
}
}
// 6th priority: tokenCreator w/ or w/o requiring 165 from contract or override
if (creator != address(0)) {
// Only pay the tokenCreator if there wasn't another royalty defined
recipients = new address payable[](1);
recipients[0] = creator;
splitPerRecipientInBasisPoints = new uint256[](1);
// The split amount is assumed to be 100% when only 1 recipient is returned
return (recipients, splitPerRecipientInBasisPoints);
}
// 7th priority: owner from contract or override
try IOwnable(nftContract).owner{ gas: READ_ONLY_GAS_LIMIT }() returns (address owner) {
if (owner != address(0)) {
// Only pay the owner if there wasn't another royalty defined
recipients = new address payable[](1);
recipients[0] = payable(owner);
splitPerRecipientInBasisPoints = new uint256[](1);
// The split amount is assumed to be 100% when only 1 recipient is returned
return (recipients, splitPerRecipientInBasisPoints);
}
} catch {
// Fall through
}
// If no valid payment address or creator is found, return 0 recipients
}
/**
* @notice Calculates how funds should be distributed for the given sale details.
* @dev When the NFT is being sold by the `tokenCreator`, all the seller revenue will
* be split with the royalty recipients defined for that NFT.
*/
function _getFees(
address nftContract,
uint256 tokenId,
address payable seller,
uint256 price,
address payable buyReferrer,
uint16 sellerReferrerTakeRateInBasisPoints
)
private
view
returns (
uint256 totalFees,
address payable[] memory creatorRecipients,
uint256[] memory creatorShares,
uint256 sellerRev,
uint256 buyReferrerFee,
uint256 sellerReferrerFee
)
{
// Calculate the protocol fee
totalFees = (price * _getProtocolFee(nftContract)) / BASIS_POINTS;
address payable creator;
try implementationAddress.internalGetTokenCreator(nftContract, tokenId) returns (address payable _creator) {
creator = _creator;
} catch {
// Fall through
}
try implementationAddress.internalGetImmutableRoyalties(nftContract, tokenId) returns (
address payable[] memory _recipients,
uint256[] memory _splitPerRecipientInBasisPoints
) {
(creatorRecipients, creatorShares) = (_recipients, _splitPerRecipientInBasisPoints);
} catch {
// Fall through
}
if (creatorRecipients.length == 0) {
// Check mutable royalties only if we didn't find results from the immutable API
try implementationAddress.internalGetMutableRoyalties(nftContract, tokenId, creator) returns (
address payable[] memory _recipients,
uint256[] memory _splitPerRecipientInBasisPoints
) {
(creatorRecipients, creatorShares) = (_recipients, _splitPerRecipientInBasisPoints);
} catch {
// Fall through
}
}
if (creatorRecipients.length != 0 || assumePrimarySale) {
uint256 creatorRev;
if (assumePrimarySale) {
// All revenue should go to the creator recipients
unchecked {
// totalFees is always < price.
creatorRev = price - totalFees;
}
if (creatorRecipients.length == 0) {
// If no creators were found via the royalty APIs, then set that recipient to the seller's address
creatorRecipients = new address payable[](1);
creatorRecipients[0] = seller;
creatorShares = new uint256[](1);
// The split amount is assumed to be 100% when only 1 recipient is returned
}
} else if (seller == creator || (creatorRecipients.length != 0 && seller == creatorRecipients[0])) {
// When sold by the creator, all revenue is split if applicable.
unchecked {
// totalFees is always < price.
creatorRev = price - totalFees;
}
} else {
// Rounding favors the owner first, then creator, and foundation last.
unchecked {
// Safe math is not required when dividing by a non-zero constant.
creatorRev = price / CREATOR_ROYALTY_DENOMINATOR;
}
sellerRev = price - totalFees - creatorRev;
}
// Cap the max number of recipients supported
creatorRecipients.capLength(MAX_ROYALTY_RECIPIENTS);
creatorShares.capLength(MAX_ROYALTY_RECIPIENTS);
// Calculate the seller referrer fee when some revenue is awarded to the creator
if (sellerReferrerTakeRateInBasisPoints != 0) {
sellerReferrerFee = (price * sellerReferrerTakeRateInBasisPoints) / BASIS_POINTS;
// Subtract the seller referrer fee from the seller revenue so we do not double pay.
if (sellerRev == 0) {
// If the seller revenue is 0, this is a primary sale where all seller revenue is attributed to the "creator".
creatorRev -= sellerReferrerFee;
} else {
sellerRev -= sellerReferrerFee;
}
}
// Sum the total shares defined
uint256 totalShares;
if (creatorRecipients.length > 1) {
unchecked {
for (uint256 i = 0; i < creatorRecipients.length; ++i) {
if (creatorRecipients[i] == seller) {
// If the seller is any of the recipients defined, assume a primary sale
creatorRev += sellerRev;
sellerRev = 0;
}
if (totalShares != type(uint256).max) {
if (creatorShares[i] > BASIS_POINTS) {
// If the numbers are >100% we ignore the fee recipients and pay just the first instead
totalShares = type(uint256).max;
// Continue the loop in order to detect a potential primary sale condition
} else {
totalShares += creatorShares[i];
}
}
}
}
if (totalShares == 0 || totalShares == type(uint256).max) {
// If no shares were defined or shares were out of bounds, pay only the first recipient
creatorRecipients.capLength(1);
creatorShares.capLength(1);
}
}
// Send payouts to each additional recipient if more than 1 was defined
uint256 totalRoyaltiesDistributed;
for (uint256 i = 1; i < creatorRecipients.length; ) {
uint256 royalty = (creatorRev * creatorShares[i]) / totalShares;
totalRoyaltiesDistributed += royalty;
creatorShares[i] = royalty;
unchecked {
++i;
}
}
// Send the remainder to the 1st creator, rounding in their favor
creatorShares[0] = creatorRev - totalRoyaltiesDistributed;
} else {
// No royalty recipients found.
unchecked {
// totalFees is always < price.
sellerRev = price - totalFees;
}
// Calculate the seller referrer fee when there is no creator royalty
if (sellerReferrerTakeRateInBasisPoints != 0) {
sellerReferrerFee = (price * sellerReferrerTakeRateInBasisPoints) / BASIS_POINTS;
sellerRev -= sellerReferrerFee;
}
}
if (buyReferrer != address(0) && buyReferrer != _msgSender() && buyReferrer != seller && buyReferrer != creator) {
unchecked {
buyReferrerFee = price / BUY_REFERRER_FEE_DENOMINATOR;
// buyReferrerFee is always <= totalFees
totalFees -= buyReferrerFee;
}
}
}
/**
* @notice Calculates the protocol fee for the given NFT contract.
* @dev This returns the contract's default fee but may be overridden to change fees based on the collection type.
*/
function _getProtocolFee(address /* nftContract */) internal view virtual returns (uint256 protocolFeeInBasisPoints) {
protocolFeeInBasisPoints = DEFAULT_PROTOCOL_FEE_IN_BASIS_POINTS;
}
/**
* @notice 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[500] private __gap;
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
import "./FETHNode.sol";
/**
* @title A place for common modifiers and functions used by various market mixins, if any.
* @dev This also leaves a gap which can be used to add a new mixin to the top of the inheritance tree.
* @author batu-inal & HardlyDifficult
*/
abstract contract MarketSharedCore is FETHNode {
/**
* @notice Checks who the seller for an NFT is if listed in this market.
* @param nftContract The address of the NFT contract.
* @param tokenId The id of the NFT.
* @return seller The seller which listed this NFT for sale, or address(0) if not listed.
*/
function getSellerOf(address nftContract, uint256 tokenId) external view returns (address payable seller) {
seller = _getSellerOf(nftContract, tokenId);
}
/**
* @notice Checks who the seller for an NFT is if listed in this market.
*/
function _getSellerOf(address nftContract, uint256 tokenId) internal view virtual returns (address payable seller);
/**
* @notice Checks who the seller for an NFT is if listed in this market or returns the current owner.
*/
function _getSellerOrOwnerOf(
address nftContract,
uint256 tokenId
) internal view virtual returns (address payable sellerOrOwner);
/**
* @notice 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[500] private __gap;
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
error RouterContext_Not_A_Contract();
/**
* @title Enables a trusted router contract to override the usual msg.sender address.
* @author HardlyDifficult
*/
abstract contract RouterContext is Context {
using AddressUpgradeable for address;
address private immutable approvedRouter;
constructor(address router) {
if (!router.isContract()) {
revert RouterContext_Not_A_Contract();
}
approvedRouter = router;
}
/**
* @notice Returns the router contract which is able to override the msg.sender address.
* @return router The address of the trusted router.
*/
function getApprovedRouterAddress() external view returns (address router) {
router = approvedRouter;
}
/**
* @notice Returns the sender of the transaction.
* @dev If the msg.sender is the trusted router contract, then the last 20 bytes of the calldata is the authorized
* sender.
*/
function _msgSender() internal view virtual override returns (address sender) {
sender = super._msgSender();
if (sender == approvedRouter) {
assembly {
// The router appends the msg.sender to the end of the calldata
// source: https://github.com/opengsn/gsn/blob/v3.0.0-beta.3/packages/contracts/src/ERC2771Recipient.sol#L48
sender := shr(96, calldataload(sub(calldatasize(), 20)))
}
}
}
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "./FETHNode.sol";
/**
* @title A mixin for sending ETH with a fallback withdraw mechanism.
* @notice Attempt to send ETH and if the transfer fails or runs out of gas, store the balance
* in the FETH token contract for future withdrawal instead.
* @dev This mixin was recently switched to escrow funds in FETH.
* Once we have confirmed all pending balances have been withdrawn, we can remove the escrow tracking here.
* @author batu-inal & HardlyDifficult
*/
abstract contract SendValueWithFallbackWithdraw is FETHNode {
using AddressUpgradeable for address payable;
/// @dev Removing old unused variables in an upgrade safe way.
uint256 private __gap_was_pendingWithdrawals;
/**
* @notice Emitted when escrowed funds are withdrawn to FETH.
* @param user The account which has withdrawn ETH.
* @param amount The amount of ETH which has been withdrawn.
*/
event WithdrawalToFETH(address indexed user, uint256 amount);
/**
* @notice Attempt to send a user or contract ETH.
* If it fails store the amount owned for later withdrawal in FETH.
* @dev This may fail when sending ETH to a contract that is non-receivable or exceeds the gas limit specified.
*/
function _sendValueWithFallbackWithdraw(address payable user, uint256 amount, uint256 gasLimit) internal {
if (amount == 0) {
return;
}
// Cap the gas to prevent consuming all available gas to block a tx from completing successfully
// solhint-disable-next-line avoid-low-level-calls
(bool success, ) = user.call{ value: amount, gas: gasLimit }("");
if (!success) {
// Store the funds that failed to send for the user in the FETH token
feth.depositFor{ value: amount }(user);
emit WithdrawalToFETH(user, amount);
}
}
/**
* @notice 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[999] private __gap;
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
import "../../libraries/TimeLibrary.sol";
error TxDeadline_Tx_Deadline_Expired();
/**
* @title A mixin that provides a modifier to check that a transaction deadline has not expired.
* @author HardlyDifficult
*/
abstract contract TxDeadline {
using TimeLibrary for uint256;
/// @notice Requires the deadline provided is 0, now, or in the future.
modifier txDeadlineNotExpired(uint256 txDeadlineTime) {
// No transaction deadline when set to 0.
if (txDeadlineTime != 0 && txDeadlineTime.hasExpired()) {
revert TxDeadline_Tx_Deadline_Expired();
}
_;
}
// This mixin does not use any storage.
}
/*
･
* ★
･ ｡
･ ﾟ☆ ｡
* ★ ﾟ･｡ * ｡
* ☆ ｡･ﾟ*.｡
ﾟ *.｡☆｡★ ･
` .-:::::-.` `-::---...```
`-:` .:+ssssoooo++//:.` .-/+shhhhhhhhhhhhhyyyssooo:
.--::. .+ossso+/////++/:://-` .////+shhhhhhhhhhhhhhhhhhhhhy
`-----::. `/+////+++///+++/:--:/+/- -////+shhhhhhhhhhhhhhhhhhhhhy
`------:::-` `//-.``.-/+ooosso+:-.-/oso- -////+shhhhhhhhhhhhhhhhhhhhhy
.--------:::-` :+:.` .-/osyyyyyyso++syhyo.-////+shhhhhhhhhhhhhhhhhhhhhy
`-----------:::-. +o+:-.-:/oyhhhhhhdhhhhhdddy:-////+shhhhhhhhhhhhhhhhhhhhhy
.------------::::-- `oys+/::/+shhhhhhhdddddddddy/-////+shhhhhhhhhhhhhhhhhhhhhy
.--------------:::::-` +ys+////+yhhhhhhhddddddddhy:-////+yhhhhhhhhhhhhhhhhhhhhhy
`----------------::::::-`.ss+/:::+oyhhhhhhhhhhhhhhho`-////+shhhhhhhhhhhhhhhhhhhhhy
.------------------:::::::.-so//::/+osyyyhhhhhhhhhys` -////+shhhhhhhhhhhhhhhhhhhhhy
`.-------------------::/:::::..+o+////+oosssyyyyyyys+` .////+shhhhhhhhhhhhhhhhhhhhhy
.--------------------::/:::.` -+o++++++oooosssss/. `-//+shhhhhhhhhhhhhhhhhhhhyo
.------- ``````.......--` `-/+ooooosso+/-` `./++++///:::--...``hhhhyo
`````
*
･ ｡
･ ﾟ☆ ｡
* ★ ﾟ･｡ * ｡
* ☆ ｡･ﾟ*.｡
ﾟ *.｡☆｡★ ･
* ﾟ｡·*･｡ ﾟ*
☆ﾟ･｡°*. ﾟ
･ ﾟ*｡･ﾟ★｡
･ *ﾟ｡ *
･ﾟ*｡★･
☆∴｡ *
･ ｡
*/
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "./mixins/shared/FETHNode.sol";
import "./mixins/shared/FoundationTreasuryNode.sol";
import "./mixins/shared/Gap9000.sol";
import "./mixins/shared/Gap500.sol";
import "./mixins/shared/MarketFees.sol";
import "./mixins/shared/MarketSharedCore.sol";
import "./mixins/shared/RouterContext.sol";
import "./mixins/shared/SendValueWithFallbackWithdraw.sol";
import "./mixins/shared/TxDeadline.sol";
import "./mixins/nftDropMarket/NFTDropMarketCore.sol";
import "./mixins/nftDropMarket/NFTDropMarketFixedPriceSale.sol";
import "./mixins/nftDropMarket/NFTDropMarketExhibition.sol";
error NFTDropMarket_NFT_Already_Minted();
/**
* @title A market for minting NFTs with Foundation.
* @author batu-inal & HardlyDifficult & philbirt & reggieag
*/
contract NFTDropMarket is
TxDeadline,
Initializable,
FoundationTreasuryNode,
Context,
RouterContext,
FETHNode,
MarketSharedCore,
NFTDropMarketCore,
ReentrancyGuardUpgradeable,
SendValueWithFallbackWithdraw,
MarketFees,
Gap500,
Gap9000,
NFTDropMarketExhibition,
NFTDropMarketFixedPriceSale
{
/**
* @notice Set immutable variables for the implementation contract.
* @dev Using immutable instead of constants allows us to use different values on testnet.
* @param treasury The Foundation Treasury contract address.
* @param feth The FETH ERC-20 token contract address.
* @param royaltyRegistry The Royalty Registry contract address.
* @param nftMarket The NFT Market contract address, containing exhibition definitions.
* @param router The trusted router contract address.
*/
constructor(
address payable treasury,
address feth,
address royaltyRegistry,
address nftMarket,
address router
)
FoundationTreasuryNode(treasury)
FETHNode(feth)
MarketFees(
/* protocolFeeInBasisPoints: */
1500,
royaltyRegistry,
/* assumePrimarySale: */
true
)
NFTDropMarketExhibition(nftMarket)
RouterContext(router)
{
_disableInitializers();
}
/**
* @notice Called once to configure the contract after the initial proxy deployment.
* @dev This farms the initialize call out to inherited contracts as needed to initialize mutable variables.
*/
function initialize() external initializer {
ReentrancyGuardUpgradeable.__ReentrancyGuard_init();
}
/**
* @inheritdoc MarketSharedCore
* @dev Returns address(0) if the NFT has already been sold, otherwise checks for a listing in this market.
*/
function _getSellerOf(
address nftContract,
uint256 tokenId
) internal view override(MarketSharedCore, NFTDropMarketFixedPriceSale) returns (address payable seller) {
// Check the current owner first in case it has been sold.
try IERC721(nftContract).ownerOf(tokenId) returns (address owner) {
if (owner != address(0)) {
// If sold, return address(0) since that owner cannot sell via this market.
return payable(address(0));
}
} catch {
// Fall through
}
return super._getSellerOf(nftContract, tokenId);
}
/**
* @inheritdoc NFTDropMarketFixedPriceSale
*/
function _getProtocolFee(
address nftContract
) internal view override(MarketFees, NFTDropMarketFixedPriceSale) returns (uint256 protocolFeeInBasisPoints) {
protocolFeeInBasisPoints = super._getProtocolFee(nftContract);
}
/**
* @inheritdoc MarketSharedCore
* @dev Reverts if the NFT has already been sold, otherwise checks for a listing in this market.
*/
function _getSellerOrOwnerOf(
address nftContract,
uint256 tokenId
) internal view override returns (address payable sellerOrOwner) {
// Check the current owner first in case it has been sold.
try IERC721(nftContract).ownerOf(tokenId) returns (address owner) {
if (owner != address(0)) {
// Once an NFT has been minted, it cannot be sold through this contract.
revert NFTDropMarket_NFT_Already_Minted();
}
} catch {
// Fall through
}
sellerOrOwner = super._getSellerOf(nftContract, tokenId);
}
/**
* @inheritdoc RouterContext
*/
function _msgSender() internal view override(Context, RouterContext) returns (address sender) {
sender = super._msgSender();
}
}