Token Rare Pepes Cult
Overview CRC721
Total Supply:
1,955 RPC
Holders:
113 addresses
Transfers:
-
Contract:
[ Download CSV Export ]
[ Download CSV Export ]
| # | Exchange | Pair | Price | 24H Volume | % Volume |
|---|
Contract Name:
RarePepesCult
Compiler Version
v0.8.15+commit.e14f2714
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)
pragma solidity ^0.8.0;
import "../utils/introspection/IERC165.sol";
/**
* @dev Interface for the NFT Royalty Standard.
*
* A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
* support for royalty payments across all NFT marketplaces and ecosystem participants.
*
* _Available since v4.5._
*/
interface IERC2981 is IERC165 {
/**
* @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
* exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract Pausable is Context {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
constructor() {
_paused = false;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
_requireNotPaused();
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
_requirePaused();
_;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
return _paused;
}
/**
* @dev Throws if the contract is paused.
*/
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
/**
* @dev Throws if the contract is not paused.
*/
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)
pragma solidity ^0.8.0;
import "../../interfaces/IERC2981.sol";
import "../../utils/introspection/ERC165.sol";
/**
* @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
*
* Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
* specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
*
* Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
* fee is specified in basis points by default.
*
* IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
* https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
* voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
*
* _Available since v4.5._
*/
abstract contract ERC2981 is IERC2981, ERC165 {
struct RoyaltyInfo {
address receiver;
uint96 royaltyFraction;
}
RoyaltyInfo private _defaultRoyaltyInfo;
mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @inheritdoc IERC2981
*/
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];
if (royalty.receiver == address(0)) {
royalty = _defaultRoyaltyInfo;
}
uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();
return (royalty.receiver, royaltyAmount);
}
/**
* @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
* fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
* override.
*/
function _feeDenominator() internal pure virtual returns (uint96) {
return 10000;
}
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
require(receiver != address(0), "ERC2981: invalid receiver");
_defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
}
/**
* @dev Removes default royalty information.
*/
function _deleteDefaultRoyalty() internal virtual {
delete _defaultRoyaltyInfo;
}
/**
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function _setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) internal virtual {
require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
require(receiver != address(0), "ERC2981: Invalid parameters");
_tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
}
/**
* @dev Resets royalty information for the token id back to the global default.
*/
function _resetTokenRoyalty(uint256 tokenId) internal virtual {
delete _tokenRoyaltyInfo[tokenId];
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.2) (token/ERC721/ERC721.sol)
pragma solidity ^0.8.0;
import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./extensions/IERC721Metadata.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/Strings.sol";
import "../../utils/introspection/ERC165.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _ownerOf(tokenId);
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return "";
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
*/
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _ownerOf(tokenId) != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId, 1);
// Check that tokenId was not minted by `_beforeTokenTransfer` hook
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
// Will not overflow unless all 2**256 token ids are minted to the same owner.
// Given that tokens are minted one by one, it is impossible in practice that
// this ever happens. Might change if we allow batch minting.
// The ERC fails to describe this case.
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId, 1);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
* This is an internal function that does not check if the sender is authorized to operate on the token.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
// Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
owner = ERC721.ownerOf(tokenId);
// Clear approvals
delete _tokenApprovals[tokenId];
unchecked {
// Cannot overflow, as that would require more tokens to be burned/transferred
// out than the owner initially received through minting and transferring in.
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId, 1);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId, 1);
// Check that tokenId was not transferred by `_beforeTokenTransfer` hook
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
// Clear approvals from the previous owner
delete _tokenApprovals[tokenId];
unchecked {
// `_balances[from]` cannot overflow for the same reason as described in `_burn`:
// `from`'s balance is the number of token held, which is at least one before the current
// transfer.
// `_balances[to]` could overflow in the conditions described in `_mint`. That would require
// all 2**256 token ids to be minted, which in practice is impossible.
_balances[from] -= 1;
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId, 1);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits an {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
/**
* @dev Reverts if the `tokenId` has not been minted yet.
*/
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
/// @solidity memory-safe-assembly
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
* - When `from` is zero, the tokens will be minted for `to`.
* - When `to` is zero, ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual {}
/**
* @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
* - When `from` is zero, the tokens were minted for `to`.
* - When `to` is zero, ``from``'s tokens were burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual {}
/**
* @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
*
* WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant
* being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such
* that `ownerOf(tokenId)` is `a`.
*/
// solhint-disable-next-line func-name-mixedcase
function __unsafe_increaseBalance(address account, uint256 amount) internal {
_balances[account] += amount;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)
pragma solidity ^0.8.0;
import "../ERC721.sol";
import "./IERC721Enumerable.sol";
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _allTokens.length;
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
return _allTokens[index];
}
/**
* @dev See {ERC721-_beforeTokenTransfer}.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual override {
super._beforeTokenTransfer(from, to, firstTokenId, batchSize);
if (batchSize > 1) {
// Will only trigger during construction. Batch transferring (minting) is not available afterwards.
revert("ERC721Enumerable: consecutive transfers not supported");
}
uint256 tokenId = firstTokenId;
if (from == address(0)) {
_addTokenToAllTokensEnumeration(tokenId);
} else if (from != to) {
_removeTokenFromOwnerEnumeration(from, tokenId);
}
if (to == address(0)) {
_removeTokenFromAllTokensEnumeration(tokenId);
} else if (to != from) {
_addTokenToOwnerEnumeration(to, tokenId);
}
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
uint256 length = ERC721.balanceOf(to);
_ownedTokens[to][length] = tokenId;
_ownedTokensIndex[tokenId] = length;
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
// To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
uint256 tokenIndex = _ownedTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
}
// This also deletes the contents at the last position of the array
delete _ownedTokensIndex[tokenId];
delete _ownedTokens[from][lastTokenIndex];
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
// To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
// rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
// This also deletes the contents at the last position of the array
delete _allTokensIndex[tokenId];
_allTokens.pop();
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)
pragma solidity ^0.8.0;
import "../IERC721.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)
pragma solidity ^0.8.0;
import "../IERC721.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}// SPDX-License-Identifier: MIT
// 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 (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)
pragma solidity ^0.8.0;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}// 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 Address {
/**
* @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 Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)
pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
import "./IERC165.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}// 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/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1);
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding
) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10**64) {
value /= 10**64;
result += 64;
}
if (value >= 10**32) {
value /= 10**32;
result += 32;
}
if (value >= 10**16) {
value /= 10**16;
result += 16;
}
if (value >= 10**8) {
value /= 10**8;
result += 8;
}
if (value >= 10**4) {
value /= 10**4;
result += 4;
}
if (value >= 10**2) {
value /= 10**2;
result += 2;
}
if (value >= 10**1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
import "./math/Math.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./ultimate/Drop.sol";
contract RarePepesCult is Drop {
constructor()
Drop(
"Rare Pepes Cult",
"RPC",
"ipfs://bafybeih7rgzkfevh4del3xc7zqe7lyowhlffc736giusu6zqzauzzw4tku",
4200,
69,
0
)
{
setRegularCost(100 ether);
setMemberCost(100 ether);
setWhitelistCost(69 ether);
setDefaultRoyalty(0xFd8c73d97814A0926Bd95F0881c50D2Df9e61E8D, 1000);
setPublicStartTime(1684962000);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./RandomlyAssigned.sol";
import "./SafeMathLite.sol";
import "./SafePct.sol";
contract Drop is
Pausable,
ERC721Enumerable,
Ownable,
RandomlyAssigned,
ERC2981
{
using Counters for Counters.Counter;
using Strings for uint256;
using SafePct for uint256;
using SafeMathLite for uint256;
string public baseURI;
uint256 public regularCost;
uint256 public memberCost;
uint256 public whitelistCost;
//Restrictions
uint256 public maxSupply;
uint256 public immutable reservedNft;
uint256 public immutable maxMintAmount;
uint16 public maxMintPerAddress = 0;
Counters.Counter public reservedMintedNFT;
address[] public partners;
address[] private payees;
uint16[] private shares;
uint256 public publicStartTime;
uint256 public whitelistStartTime;
bool public whiteListPresaleOnly = false;
struct Infos {
uint256 regularCost;
uint256 memberCost;
uint256 whitelistCost;
uint256 maxSupply;
uint256 totalSupply;
uint256 maxMintPerAddress;
uint256 maxMintPerTx;
}
mapping(address => bool) public whitelistedAddresses;
mapping(address => uint256) whitelistMinted;
uint256 internal MAX_WHITELIST_MINT = 0;
constructor(
string memory name_,
string memory symbol_,
string memory baseURI_,
uint256 maxSupply_,
uint256 maxMintAmount_,
uint256 reservedNFT_
) ERC721(name_, symbol_) RandomlyAssigned(maxSupply_, reservedNFT_) {
setBaseURI(baseURI_);
maxSupply = maxSupply_;
maxMintAmount = maxMintAmount_;
reservedNft = reservedNFT_;
_transferOwnership(tx.origin);
}
function getInfo() public view returns (Infos memory) {
Infos memory allInfos;
allInfos.regularCost = regularCost;
allInfos.memberCost = memberCost;
allInfos.whitelistCost = whitelistCost;
allInfos.maxSupply = maxSupply;
allInfos.totalSupply = totalSupply();
allInfos.maxMintPerTx = maxMintAmount;
allInfos.maxMintPerAddress = maxMintPerAddress;
return allInfos;
}
function setPartners(address[] calldata partners_) external onlyOwner {
partners = partners_;
}
function isMember(address _address) internal view returns (bool) {
for (uint i = 0; i < partners.length; i++) {
if (IERC721(partners[i]).balanceOf(_address) > 0) {
return true;
}
}
return false;
}
function addWhiteList(address[] calldata _addresses) public onlyOwner {
uint len = _addresses.length;
for (uint i = 0; i < len; i++) {
whitelistedAddresses[_addresses[i]] = true;
}
}
function addWhiteListAddress(address _address) public onlyOwner {
whitelistedAddresses[_address] = true;
}
function _removeWhiteList(address _address) internal {
if (whitelistedAddresses[_address]) {
delete whitelistedAddresses[_address];
}
}
function removeWhiteList(address _address) public onlyOwner {
_removeWhiteList(_address);
}
function setRegularCost(uint256 _cost) public onlyOwner {
regularCost = _cost;
}
function setMemberCost(uint256 _cost) public onlyOwner {
memberCost = _cost;
}
function setWhitelistCost(uint256 _cost) public onlyOwner {
whitelistCost = _cost;
}
function isWhitelist(address _address) public view virtual returns (bool) {
return whitelistedAddresses[_address];
}
function setWhiteListPresaleOnly(bool _presaleOnly) public onlyOwner {
whiteListPresaleOnly = _presaleOnly;
}
function isPresale() public view returns (bool) {
if (
block.timestamp < publicStartTime &&
block.timestamp >= whitelistStartTime
) {
return true;
} else {
return false;
}
}
function mint(uint256 _mintAmount) public payable virtual whenNotPaused {
require(msg.sender == tx.origin, "contract not allowed");
require(payees.length > 0, "no payees set");
if (whitelistStartTime != 0) {
require(block.timestamp >= whitelistStartTime, "not started");
}
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(
_mintAmount <= maxMintAmount,
"max mint amount per session exceeded"
);
require((supply + _mintAmount) <= maxSupply, "max NFT limit exceeded");
uint256 maxQty = canMint(msg.sender);
require(_mintAmount <= maxQty, "mint limit exceeded");
if (isPresale()) {
require(isWhitelist(msg.sender), "not whitelist");
if (MAX_WHITELIST_MINT > 0) {
whitelistMinted[msg.sender] += _mintAmount;
require(
whitelistMinted[msg.sender] <= MAX_WHITELIST_MINT,
"exceed amount in presale"
);
}
}
uint256 cost = mintCost(msg.sender);
uint256 totalCost = cost.mul(_mintAmount);
require(totalCost <= msg.value, "insufficient funds");
for (uint256 i = 1; i <= _mintAmount; i++) {
_mintRandomId(msg.sender);
}
uint256 len = payees.length;
uint256 amount;
for (uint256 i = 0; i < len; i++) {
amount = totalCost.mulDiv(shares[i], 10000);
_payout(amount, payees[i]);
}
if (isWhitelist(msg.sender) && MAX_WHITELIST_MINT > 0) {
if (balanceOf(msg.sender) >= MAX_WHITELIST_MINT) {
_removeWhiteList(msg.sender);
}
}
}
function _payout(uint256 _amount, address _address) private {
(bool success, ) = payable(_address).call{value: _amount, gas: 50000}(
""
);
require(success, "Cannot payout");
}
function reservedMint(address _to, uint256 _mintAmount) external onlyOwner {
require(
(reservedMintedNFT.current() + _mintAmount) <= reservedNft,
"All Reserved NFT Minted"
);
for (uint256 i = 1; i <= _mintAmount; i++) {
reservedMintedNFT.increment();
_safeMint(_to, reservedMintedNFT.current());
}
}
function reservedMintByIds(
address _to,
uint256[] calldata _ids
) public virtual onlyOwner {
uint256 supply = totalSupply();
uint256 len = _ids.length;
require((supply + len) <= maxSupply, "max NFT limit exceeded");
for (uint256 i = 0; i < len; i++) {
reserveToken(_ids[i]);
_safeMint(_to, _ids[i]);
}
}
function airdropMint(
address _to,
uint256 _amount
) public virtual onlyOwner {
uint256 supply = totalSupply();
require((supply + _amount) <= maxSupply, "max NFT limit exceeded");
for (uint256 i = 1; i <= _amount; i++) {
_mintRandomId(_to);
}
}
function _mintRandomId(address to) internal returns (uint id) {
id = nextToken();
require(id > 0 && id <= maxSupply, "Mint not possible");
_safeMint(to, id);
}
//Get NFT Cost
function mintCost(address _address) public view virtual returns (uint256) {
require(_address != address(0), "not address 0");
if (whiteListPresaleOnly) {
if (isPresale() && isWhitelist(_address)) {
return whitelistCost;
}
} else {
if (isWhitelist(_address)) {
return whitelistCost;
}
}
if (isMember(_address)) {
return memberCost;
}
return regularCost;
}
// Can Mint Function
function canMint(address _address) public view virtual returns (uint256) {
uint leftToMint = maxSupply - totalSupply();
uint maxPerAddressRemaining = maxMintPerAddress > 0
? maxMintPerAddress - balanceOf(_address)
: maxSupply;
if (isPresale()) {
if (!isWhitelist(_address)) return 0;
if (MAX_WHITELIST_MINT > 0) {
maxPerAddressRemaining =
MAX_WHITELIST_MINT -
balanceOf(_address);
}
} else if (publicStartTime > 0 && block.timestamp < publicStartTime) {
return 0;
}
if (leftToMint > maxMintAmount) leftToMint = maxMintAmount;
if (maxMintAmount > maxPerAddressRemaining)
leftToMint = maxPerAddressRemaining;
return leftToMint;
}
function tokenURI(
uint _tokenId
) public view virtual override returns (string memory) {
require(
_exists(_tokenId),
"ERC721Metadata: URI query for nonexistent token"
);
string memory _tokenURI = string(
abi.encodePacked(baseURI, "/", Strings.toString(_tokenId), ".json")
);
return _tokenURI;
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
baseURI = _newBaseURI;
}
function pause() public onlyOwner {
_pause();
}
function unpause() public onlyOwner {
_unpause();
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
return baseURI;
}
function burn(uint256 tokenId) public {
require(
_isApprovedOrOwner(_msgSender(), tokenId),
"ERC721Burnable: caller is not owner nor approved"
);
_burn(tokenId);
}
function lock() public onlyOwner {
maxSupply = totalSupply();
}
function setPaymentShares(
address[] calldata _newPayees,
uint16[] calldata _newShares
) public onlyOwner {
require(_newPayees.length != 0, "empty payees");
require(_newPayees.length == _newShares.length, "wrong payee numbers");
if (!isCorrectShares(_newShares)) {
revert("invalid shares");
}
payees = _newPayees;
shares = _newShares;
}
function getPayees() public view returns (address[] memory) {
return payees;
}
function getShares() public view returns (uint16[] memory) {
return shares;
}
function isCorrectShares(
uint16[] memory _shares
) internal pure virtual returns (bool) {
uint256 len = _shares.length;
uint256 totalFees;
for (uint256 i = 0; i < len; i++) {
totalFees += _shares[i];
}
return totalFees == 10000;
}
function setPublicStartTime(uint256 _startTime) public onlyOwner {
publicStartTime = _startTime;
}
function setWhitelistStartTime(uint256 _startTime) public onlyOwner {
whitelistStartTime = _startTime;
}
function setMaxWhiteList(uint256 _max) public onlyOwner {
MAX_WHITELIST_MINT = _max;
}
function setDefaultRoyalty(
address receiver,
uint96 feeNumerator
) public onlyOwner {
_setDefaultRoyalty(receiver, feeNumerator);
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721Enumerable, ERC2981) returns (bool) {
return super.supportsInterface(interfaceId);
}
function setMaxMintPerAddress(uint16 maxAmount) public onlyOwner {
maxMintPerAddress = maxAmount;
}
function tokensOfWallet(
address _address
) external view returns (uint256[] memory) {
uint256 ownerTokenCount = balanceOf(_address);
uint256[] memory tokenIds = new uint256[](ownerTokenCount);
for (uint256 i; i < ownerTokenCount; i++) {
tokenIds[i] = tokenOfOwnerByIndex(_address, i);
}
return tokenIds;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import './WithLimitedSupply.sol';
/// @author Modified version of original code by 1001.digital
/// @title Randomly assign tokenIDs from a given set of tokens.
abstract contract RandomlyAssigned is WithLimitedSupply {
// Used for random index assignment
mapping(uint256 => uint256) private tokenMatrix;
// The initial token ID
uint256 private immutable startFrom;
/// Instanciate the contract
/// @param maxSupply_ how many tokens this collection should hold
/// @param numReserved_ the number of tokens reserved whose IDs dont come from the randomizer
constructor(uint256 maxSupply_, uint256 numReserved_)
WithLimitedSupply(maxSupply_, numReserved_)
{
startFrom = numReserved_ + 1;
}
/// Get the next token ID
/// @dev Randomly gets a new token ID and keeps track of the ones that are still available.
/// @return the next token ID
function nextToken() internal override returns (uint256) {
uint256 maxIndex = maxAvailableSupply() - tokenCount();
uint256 random = uint256(
keccak256(
abi.encodePacked(
msg.sender,
block.coinbase,
block.difficulty,
block.gaslimit,
block.timestamp
)
)
) % maxIndex;
uint256 value = 0;
if (tokenMatrix[random] == 0) {
// If this matrix position is empty, set the value to the generated random number.
value = random;
} else {
// Otherwise, use the previously stored number from the matrix.
value = tokenMatrix[random];
}
// If the last available tokenID is still unused...
if (tokenMatrix[maxIndex - 1] == 0) {
// ...store that ID in the current matrix position.
tokenMatrix[random] = maxIndex - 1;
} else {
// ...otherwise copy over the stored number to the current matrix position.
tokenMatrix[random] = tokenMatrix[maxIndex - 1];
}
// Increment counts (ie. qty minted)
super.nextToken();
return value + startFrom;
}
function reserveToken(uint _id) internal {
require(tokenMatrix[_id - 1] == 0, 'token already reserved');
uint256 maxIndex = maxAvailableSupply() - tokenCount();
tokenMatrix[_id - 1] = maxIndex - 1;
super.nextToken();
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
library SafeMathLite {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
/**
* @dev Compute percentages safely without phantom overflows.
*
* Intermediate operations can overflow even when the result will always
* fit into computed type. Developers usually
* assume that overflows raise errors. `SafePct` 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.
*/
import "./SafeMathLite.sol";
library SafePct {
using SafeMathLite for uint256;
/**
* Requirements:
*
* - intermediate operations must revert on overflow
*/
function mulDiv(
uint256 x,
uint256 y,
uint256 z
) internal pure returns (uint256) {
require(z > 0, "Division by zero");
if (x == 0) return 0;
uint256 xy = x * y;
if (xy / x == y) {
// no overflow happened - same as in SafeMath mul
return xy / z;
}
//slither-disable-next-line divide-before-multiply
uint256 a = x / z;
uint256 b = x % z; // x = a * z + b
//slither-disable-next-line divide-before-multiply
uint256 c = y / z;
uint256 d = y % z; // y = c * z + d
return
(a.mul(c).mul(z)).add(a.mul(d)).add(b.mul(c)).add(b.mul(d).div(z));
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
/// @author Modified version of original code by 1001.digital
/// @title A token tracker that limits the token supply and increments token IDs on each new mint.
abstract contract WithLimitedSupply {
// Keeps track of how many we have minted
uint256 private _tokenCount;
/// @dev The maximum count of tokens this token tracker will issue.
uint256 private immutable _maxAvailableSupply;
/// Instanciate the contract
/// @param maxSupply_ how many tokens this collection should hold
constructor(uint256 maxSupply_, uint256 reserved_) {
_maxAvailableSupply = maxSupply_ - reserved_;
}
function maxAvailableSupply() public view returns (uint256) {
return _maxAvailableSupply;
}
/// @dev Get the current token count
/// @return the created token count
/// TODO: if this is not required externally, does making it `public view` use unneccary gas?
function tokenCount() public view returns (uint256) {
return _tokenCount;
}
/// @dev Check whether tokens are still available
/// @return the available token count
function availableTokenCount() public view returns (uint256) {
return maxAvailableSupply() - tokenCount();
}
/// @dev Increment the token count and fetch the latest count
/// @return the next token id
function nextToken() internal virtual ensureAvailability returns (uint256) {
return _tokenCount++;
}
/// @dev Check whether another token is still available
modifier ensureAvailability() {
require(availableTokenCount() > 0, "No more tokens available");
_;
}
/// @param amount Check whether number of tokens are still available
/// @dev Check whether tokens are still available
modifier ensureAvailabilityFor(uint256 amount) {
require(
availableTokenCount() >= amount,
"Requested number of tokens not available"
);
_;
}
}{
"optimizer": {
"enabled": true,
"runs": 200
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"libraries": {}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"}],"name":"addWhiteList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"addWhiteListAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"airdropMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"availableTokenCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"canMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getInfo","outputs":[{"components":[{"internalType":"uint256","name":"regularCost","type":"uint256"},{"internalType":"uint256","name":"memberCost","type":"uint256"},{"internalType":"uint256","name":"whitelistCost","type":"uint256"},{"internalType":"uint256","name":"maxSupply","type":"uint256"},{"internalType":"uint256","name":"totalSupply","type":"uint256"},{"internalType":"uint256","name":"maxMintPerAddress","type":"uint256"},{"internalType":"uint256","name":"maxMintPerTx","type":"uint256"}],"internalType":"struct Drop.Infos","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPayees","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getShares","outputs":[{"internalType":"uint16[]","name":"","type":"uint16[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPresale","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"isWhitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxAvailableSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintPerAddress","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"memberCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"mintCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"partners","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"regularCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"removeWhiteList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"reservedMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256[]","name":"_ids","type":"uint256[]"}],"name":"reservedMintByIds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reservedMintedNFT","outputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"reservedNft","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"feeNumerator","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"maxAmount","type":"uint16"}],"name":"setMaxMintPerAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_max","type":"uint256"}],"name":"setMaxWhiteList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cost","type":"uint256"}],"name":"setMemberCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"partners_","type":"address[]"}],"name":"setPartners","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_newPayees","type":"address[]"},{"internalType":"uint16[]","name":"_newShares","type":"uint16[]"}],"name":"setPaymentShares","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_startTime","type":"uint256"}],"name":"setPublicStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cost","type":"uint256"}],"name":"setRegularCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_presaleOnly","type":"bool"}],"name":"setWhiteListPresaleOnly","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cost","type":"uint256"}],"name":"setWhitelistCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_startTime","type":"uint256"}],"name":"setWhitelistStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"tokensOfWallet","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"whiteListPresaleOnly","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistedAddresses","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]Contract Creation Code
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